feat(infisical-pg): completed root folder level secret, secret import and folder

frontend/src/hooks/api/secretImports/mutation.tsx

@@ -9,21 +9,21 @@ export const useCreateSecretImport = () => {
   const queryClient = useQueryClient();
 
   return useMutation<{}, {}, TCreateSecretImportDTO>({
-    mutationFn: async ({ secretImport, environment, workspaceId, directory }) => {
+    mutationFn: async ({ import: secretImport, environment, projectId, path }) => {
       const { data } = await apiRequest.post("/api/v1/secret-imports", {
-        secretImport,
+        import: secretImport,
         environment,
-        workspaceId,
-        directory
+        projectId,
+        path
       });
       return data;
     },
-    onSuccess: (_, { workspaceId, environment, directory }) => {
+    onSuccess: (_, { environment, projectId, path }) => {
       queryClient.invalidateQueries(
-        secretImportKeys.getProjectSecretImports({ workspaceId, environment, directory })
+        secretImportKeys.getProjectSecretImports({ projectId, environment, path })
       );
       queryClient.invalidateQueries(
-        secretImportKeys.getSecretImportSecrets({ workspaceId, environment, directory })
+        secretImportKeys.getSecretImportSecrets({ projectId, environment, path })
       );
     }
   });
@@ -33,21 +33,21 @@ export const useUpdateSecretImport = () => {
   const queryClient = useQueryClient();
 
   return useMutation<{}, {}, TUpdateSecretImportDTO>({
-    mutationFn: async ({ environment, workspaceId, directory, secretImports, id }) => {
-      const { data } = await apiRequest.put(`/api/v1/secret-imports/${id}`, {
-        secretImports,
+    mutationFn: async ({ environment, import: secretImports, projectId, path, id }) => {
+      const { data } = await apiRequest.patch(`/api/v1/secret-imports/${id}`, {
+        import: secretImports,
         environment,
-        workspaceId,
-        directory
+        path,
+        projectId
       });
       return data;
     },
-    onSuccess: (_, { workspaceId, environment, directory }) => {
+    onSuccess: (_, { environment, projectId, path }) => {
       queryClient.invalidateQueries(
-        secretImportKeys.getProjectSecretImports({ workspaceId, environment, directory })
+        secretImportKeys.getProjectSecretImports({ projectId, path, environment })
       );
       queryClient.invalidateQueries(
-        secretImportKeys.getSecretImportSecrets({ workspaceId, environment, directory })
+        secretImportKeys.getSecretImportSecrets({ environment, path, projectId })
       );
     }
   });
@@ -57,21 +57,22 @@ export const useDeleteSecretImport = () => {
   const queryClient = useQueryClient();
 
   return useMutation<{}, {}, TDeleteSecretImportDTO>({
-    mutationFn: async ({ id, secretImportEnv, secretImportPath }) => {
+    mutationFn: async ({ id, projectId, path, environment }) => {
       const { data } = await apiRequest.delete(`/api/v1/secret-imports/${id}`, {
         data: {
-          secretImportPath,
-          secretImportEnv
+          projectId,
+          path,
+          environment
         }
       });
       return data;
     },
-    onSuccess: (_, { workspaceId, environment, directory }) => {
+    onSuccess: (_, { projectId, environment, path }) => {
       queryClient.invalidateQueries(
-        secretImportKeys.getProjectSecretImports({ workspaceId, environment, directory })
+        secretImportKeys.getProjectSecretImports({ projectId, environment, path })
       );
       queryClient.invalidateQueries(
-        secretImportKeys.getSecretImportSecrets({ workspaceId, environment, directory })
+        secretImportKeys.getSecretImportSecrets({ projectId, environment, path })
       );
     }
   });

frontend/src/hooks/api/secretImports/queries.tsx

@@ -7,44 +7,44 @@ import {
 } from "@app/components/utilities/cryptography/crypto";
 import { apiRequest } from "@app/config/request";
 
-import { TGetImportedSecrets, TGetSecretImports, TImportedSecrets, TSecretImports } from "./types";
+import { TGetImportedSecrets, TGetSecretImports, TImportedSecrets, TSecretImport } from "./types";
 
 export const secretImportKeys = {
-  getProjectSecretImports: ({ environment, workspaceId, directory }: TGetSecretImports) =>
-    [{ workspaceId, directory, environment }, "secrets-imports"] as const,
+  getProjectSecretImports: ({ environment, projectId, path }: TGetSecretImports) =>
+    [{ projectId, path, environment }, "secrets-imports"] as const,
   getSecretImportSecrets: ({
-    workspaceId,
     environment,
-    directory
+    projectId,
+    path
   }: Omit<TGetImportedSecrets, "decryptFileKey">) =>
-    [{ workspaceId, environment, directory }, "secrets-import-sec"] as const
+    [{ environment, path, projectId }, "secrets-import-sec"] as const
 };
 
-const fetchSecretImport = async ({ workspaceId, environment, directory }: TGetSecretImports) => {
-  const { data } = await apiRequest.get<{ secretImport: TSecretImports }>(
+const fetchSecretImport = async ({ projectId, environment, path = "/" }: TGetSecretImports) => {
+  const { data } = await apiRequest.get<{ secretImports: TSecretImport[] }>(
     "/api/v1/secret-imports",
     {
       params: {
-        workspaceId,
+        projectId,
         environment,
-        directory
+        path
       }
     }
   );
-  return data.secretImport;
+  return data.secretImports;
 };
 
 export const useGetSecretImports = ({
-  workspaceId,
   environment,
-  directory = "/",
+  path = "/",
+  projectId,
   options = {}
 }: TGetSecretImports & {
   options?: Omit<
     UseQueryOptions<
-      TSecretImports,
+      TSecretImport[],
       unknown,
-      TSecretImports,
+      TSecretImport[],
       ReturnType<typeof secretImportKeys.getProjectSecretImports>
     >,
     "queryKey" | "queryFn"
@@ -52,9 +52,9 @@ export const useGetSecretImports = ({
 }) =>
   useQuery({
     ...options,
-    queryKey: secretImportKeys.getProjectSecretImports({ workspaceId, environment, directory }),
-    enabled: Boolean(workspaceId) && Boolean(environment) && (options?.enabled ?? true),
-    queryFn: () => fetchSecretImport({ workspaceId, environment, directory })
+    queryKey: secretImportKeys.getProjectSecretImports({ environment, projectId, path }),
+    enabled: Boolean(projectId) && Boolean(environment) && (options?.enabled ?? true),
+    queryFn: () => fetchSecretImport({ path, projectId, environment })
   });
 
 const fetchImportedSecrets = async (
@@ -76,10 +76,10 @@ const fetchImportedSecrets = async (
 };
 
 export const useGetImportedSecrets = ({
-  workspaceId,
   environment,
   decryptFileKey,
-  directory,
+  path,
+  projectId,
   options = {}
 }: TGetImportedSecrets & {
   options?: Omit<
@@ -94,16 +94,16 @@ export const useGetImportedSecrets = ({
 }) =>
   useQuery({
     enabled:
-      Boolean(workspaceId) &&
+      Boolean(projectId) &&
       Boolean(environment) &&
       Boolean(decryptFileKey) &&
       (options?.enabled ?? true),
     queryKey: secretImportKeys.getSecretImportSecrets({
-      workspaceId,
       environment,
-      directory
+      path,
+      projectId
     }),
-    queryFn: () => fetchImportedSecrets(workspaceId, environment, directory),
+    queryFn: () => fetchImportedSecrets(projectId, environment, path),
     select: useCallback(
       (data: TImportedSecrets[]) => {
         const PRIVATE_KEY = localStorage.getItem("PRIVATE_KEY") as string;

frontend/src/hooks/api/secretImports/types.ts

@@ -1,12 +1,16 @@
 import { UserWsKeyPair } from "../keys/types";
 import { EncryptedSecret } from "../secrets/types";
 
-export type TSecretImports = {
+export type TSecretImport = {
   id: string;
-  workspaceId: string;
-  environment: string;
   folderId: string;
-  imports: Array<{ environment: string; secretPath: string }>;
+  importPath: string;
+  importEnv: {
+    name: string;
+    slug: string;
+    id: string;
+  };
+  position: string;
   createdAt: string;
   updatedAt: string;
 };
@@ -19,44 +23,43 @@ export type TImportedSecrets = {
 };
 
 export type TGetSecretImports = {
-  workspaceId: string;
+  projectId: string;
   environment: string;
-  directory?: string;
+  path?: string;
 };
 
 export type TGetImportedSecrets = {
-  workspaceId: string;
+  projectId: string;
   environment: string;
-  directory?: string;
+  path?: string;
   decryptFileKey: UserWsKeyPair;
 };
 
 export type TCreateSecretImportDTO = {
-  workspaceId: string;
+  projectId: string;
   environment: string;
-  directory?: string;
-  secretImport: {
+  path?: string;
+  import: {
     environment: string;
-    secretPath: string;
+    path: string;
   };
 };
 
 export type TUpdateSecretImportDTO = {
   id: string;
-  workspaceId: string;
+  projectId: string;
   environment: string;
-  directory?: string;
-  secretImports: Array<{
+  path?: string;
+  import: Partial<{
     environment: string;
-    secretPath: string;
+    path: string;
+    position: number;
   }>;
 };
 
 export type TDeleteSecretImportDTO = {
   id: string;
-  workspaceId: string;
+  projectId: string;
   environment: string;
-  directory?: string;
-  secretImportPath: string;
-  secretImportEnv: string;
+  path?: string;
 };