feat(infisical-pg): added routes for workspaces and updated frontend

backend-pg/src/server/routes/index.ts

@@ -18,6 +18,16 @@ import { orgDalFactory } from "@app/services/org/org-dal";
 import { orgRoleDalFactory } from "@app/services/org/org-role-dal";
 import { orgRoleServiceFactory } from "@app/services/org/org-role-service";
 import { orgServiceFactory } from "@app/services/org/org-service";
+import { projectDalFactory } from "@app/services/project/project-dal";
+import { projectServiceFactory } from "@app/services/project/project-service";
+import { projectEnvDalFactory } from "@app/services/project-env/project-env-dal";
+import { projectEnvServiceFactory } from "@app/services/project-env/project-env-service";
+import { projectKeyDalFactory } from "@app/services/project-key/project-key-dal";
+import { projectKeyServiceFactory } from "@app/services/project-key/project-key-service";
+import { projectMembershipDalFactory } from "@app/services/project-membership/project-membership-dal";
+import { projectMembershipServiceFactory } from "@app/services/project-membership/project-membership-service";
+import { projectRoleDalFactory } from "@app/services/project-role/project-role-dal";
+import { projectRoleServiceFactory } from "@app/services/project-role/project-role-service";
 import { TSmtpService } from "@app/services/smtp/smtp-service";
 import { superAdminDalFactory } from "@app/services/super-admin/super-admin-dal";
 import { superAdminServiceFactory } from "@app/services/super-admin/super-admin-service";
@@ -43,6 +53,12 @@ export const registerRoutes = async (
   const superAdminDal = superAdminDalFactory(db);
   const apiKeyDal = apiKeyDalFactory(db);
 
+  const projectDal = projectDalFactory(db);
+  const projectMembershipDal = projectMembershipDalFactory(db);
+  const projectRoleDal = projectRoleDalFactory(db);
+  const projectEnvDal = projectEnvDalFactory(db);
+  const projectKeyDal = projectKeyDalFactory(db);
+
   // ee db layer ops
   const permissionDal = permissionDalFactory(db);
 
@@ -84,6 +100,30 @@ export const registerRoutes = async (
   });
   const apiKeyService = apiKeyServiceFactory({ apiKeyDal });
 
+  const projectService = projectServiceFactory({
+    permissionService,
+    projectDal,
+    projectEnvDal,
+    projectMembershipDal
+  });
+  const projectMembershipService = projectMembershipServiceFactory({
+    projectMembershipDal,
+    projectDal,
+    permissionService,
+    orgDal,
+    userDal,
+    smtpService,
+    projectKeyDal,
+    projectRoleDal
+  });
+  const projectEnvService = projectEnvServiceFactory({ permissionService, projectEnvDal });
+  const projectKeyService = projectKeyServiceFactory({
+    permissionService,
+    projectKeyDal,
+    projectMembershipDal
+  });
+  const projectRoleService = projectRoleServiceFactory({ permissionService, projectRoleDal });
+
   await superAdminService.initServerCfg();
   // inject all services
   server.decorate<FastifyZodProvider["services"]>("services", {
@@ -96,7 +136,12 @@ export const registerRoutes = async (
     orgRole: orgRoleService,
     apiKey: apiKeyService,
     authToken: tokenService,
-    superAdmin: superAdminService
+    superAdmin: superAdminService,
+    project: projectService,
+    projectMembership: projectMembershipService,
+    projectKey: projectKeyService,
+    projectEnv: projectEnvService,
+    projectRole: projectRoleService
   });
 
   server.decorate<FastifyZodProvider["store"]>("store", {

backend-pg/src/server/routes/v1/index.ts

@@ -3,6 +3,10 @@ import { registerAuthRoutes } from "./auth-router";
 import { registerInviteOrgRouter } from "./invite-org-router";
 import { registerOrgRouter } from "./organization-router";
 import { registerPasswordRouter } from "./password-router";
+import { registerProjectEnvRouter } from "./project-env-router";
+import { registerProjectKeyRouter } from "./project-key-router";
+import { registerProjectMembershipRouter } from "./project-membership-router";
+import { registerProjectRouter } from "./project-router";
 import { registerSsoRouter } from "./sso-router";
 import { registerUserActionRouter } from "./user-action-router";
 import { registerUserRouter } from "./user-router";
@@ -10,11 +14,20 @@ import { registerUserRouter } from "./user-router";
 export const registerV1Routes = async (server: FastifyZodProvider) => {
   await server.register(registerSsoRouter, { prefix: "/sso" });
   await server.register(registerAuthRoutes, { prefix: "/auth" });
-  // await server.register(registerSSORouter, { prefix: "/sso" });
   await server.register(registerPasswordRouter, { prefix: "/password" });
   await server.register(registerOrgRouter, { prefix: "/organization" });
   await server.register(registerAdminRouter, { prefix: "/admin" });
   await server.register(registerUserRouter, { prefix: "/user" });
   await server.register(registerInviteOrgRouter, { prefix: "/invite-org" });
   await server.register(registerUserActionRouter, { prefix: "/user-action" });
+
+  await server.register(
+    async (projectServer) => {
+      await projectServer.register(registerProjectRouter);
+      await projectServer.register(registerProjectEnvRouter);
+      await projectServer.register(registerProjectKeyRouter);
+      await projectServer.register(registerProjectMembershipRouter);
+    },
+    { prefix: "/workspace" }
+  );
 };

backend-pg/src/server/routes/v1/project-env-router.ts

@@ -0,0 +1,111 @@
+import { z } from "zod";
+
+import { ProjectEnvironmentsSchema } from "@app/db/schemas";
+import { verifyAuth } from "@app/server/plugins/auth/verify-auth";
+import { AuthMode } from "@app/services/auth/auth-type";
+
+export const registerProjectEnvRouter = async (server: FastifyZodProvider) => {
+  server.route({
+    url: "/:workspaceId/environments",
+    method: "POST",
+    schema: {
+      params: z.object({
+        workspaceId: z.string().trim()
+      }),
+      body: z.object({
+        name: z.string().trim(),
+        slug: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          message: z.string(),
+          workspace: z.string(),
+          environment: ProjectEnvironmentsSchema
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT, AuthMode.API_KEY]),
+    handler: async (req) => {
+      const environment = await server.services.projectEnv.createEnvironment({
+        actorId: req.permission.id,
+        actor: req.permission.type,
+        projectId: req.params.workspaceId,
+        ...req.body
+      });
+      return {
+        message: "Successfully created new environment",
+        workspace: req.params.workspaceId,
+        environment
+      };
+    }
+  });
+
+  server.route({
+    url: "/:workspaceId/environments/:id",
+    method: "PATCH",
+    schema: {
+      params: z.object({
+        workspaceId: z.string().trim(),
+        id: z.string().trim()
+      }),
+      body: z.object({
+        slug: z.string().trim().optional(),
+        name: z.string().trim().optional()
+      }),
+      response: {
+        200: z.object({
+          message: z.string(),
+          workspace: z.string(),
+          environment: ProjectEnvironmentsSchema
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT, AuthMode.API_KEY]),
+    handler: async (req) => {
+      const environment = await server.services.projectEnv.updateEnvironment({
+        actorId: req.permission.id,
+        actor: req.permission.type,
+        projectId: req.params.workspaceId,
+        id: req.params.id,
+        ...req.body
+      });
+      return {
+        message: "Successfully updated environment",
+        workspace: req.params.workspaceId,
+        environment
+      };
+    }
+  });
+
+  server.route({
+    url: "/:workspaceId/environments/:id",
+    method: "DELETE",
+    schema: {
+      params: z.object({
+        workspaceId: z.string().trim(),
+        id: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          message: z.string(),
+          workspace: z.string(),
+          environment: ProjectEnvironmentsSchema
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT, AuthMode.API_KEY]),
+    handler: async (req) => {
+      const environment = await server.services.projectEnv.deleteEnvironment({
+        actorId: req.permission.id,
+        actor: req.permission.type,
+        projectId: req.params.workspaceId,
+        id: req.params.id
+      });
+      return {
+        message: "Successfully deleted environment",
+        workspace: req.params.workspaceId,
+        environment
+      };
+    }
+  });
+};

backend-pg/src/server/routes/v1/project-key-router.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+
+import { verifyAuth } from "@app/server/plugins/auth/verify-auth";
+import { AuthMode } from "@app/services/auth/auth-type";
+
+export const registerProjectKeyRouter = async (server: FastifyZodProvider) => {
+  server.route({
+    url: "/:workspaceId/key",
+    method: "POST",
+    schema: {
+      params: z.object({
+        workspaceId: z.string().trim()
+      }),
+      body: z.object({
+        key: z.object({
+          encryptedKey: z.string().trim(),
+          nonce: z.string().trim(),
+          userId: z.string().trim()
+        })
+      }),
+      response: {
+        200: z.object({
+          message: z.string()
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      await server.services.projectKey.uploadProjectKeys({
+        projectId: req.params.workspaceId,
+        actor: req.permission.type,
+        actorId: req.permission.id,
+        nonce: req.body.key.nonce,
+        receiverId: req.body.key.userId,
+        encryptedKey: req.body.key.encryptedKey
+      });
+      return { message: "Successfully uploaded key to workspace" };
+    }
+  });
+};

backend-pg/src/server/routes/v1/project-membership-router.ts

@@ -0,0 +1,100 @@
+import { z } from "zod";
+
+import { ProjectMembershipsSchema, UserEncryptionKeysSchema, UsersSchema } from "@app/db/schemas";
+import { verifyAuth } from "@app/server/plugins/auth/verify-auth";
+import { AuthMode } from "@app/services/auth/auth-type";
+
+export const registerProjectMembershipRouter = async (server: FastifyZodProvider) => {
+  // TODO(akhilmhdh-pg): missing  adding multiple user workspace refer v2/membership
+
+  server.route({
+    url: "/:workspaceId/memberships",
+    method: "GET",
+    schema: {
+      params: z.object({
+        workspaceId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          memberships: ProjectMembershipsSchema.merge(
+            z.object({
+              user: UsersSchema.pick({
+                email: true,
+                firstName: true,
+                lastName: true,
+                id: true
+              }).merge(UserEncryptionKeysSchema.pick({ publicKey: true }))
+            })
+          )
+            .omit({ createdAt: true, updatedAt: true })
+            .array()
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const memberships = await server.services.projectMembership.getProjectMemberships({
+        actorId: req.permission.id,
+        actor: req.permission.type,
+        projectId: req.params.workspaceId
+      });
+      return { memberships };
+    }
+  });
+
+  server.route({
+    url: "/:workspaceId/memberships/:membershipId",
+    method: "PATCH",
+    schema: {
+      params: z.object({
+        workspaceId: z.string().trim(),
+        membershipId: z.string().trim()
+      }),
+      body: z.object({
+        role: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          membership: ProjectMembershipsSchema
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const membership = await server.services.projectMembership.updateProjectMembership({
+        actorId: req.permission.id,
+        actor: req.permission.type,
+        projectId: req.params.workspaceId,
+        membershipId: req.params.membershipId,
+        role: req.body.role
+      });
+      return { membership };
+    }
+  });
+
+  server.route({
+    url: "/:workspaceId/memberships/:membershipId",
+    method: "DELETE",
+    schema: {
+      params: z.object({
+        workspaceId: z.string().trim(),
+        membershipId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          membership: ProjectMembershipsSchema
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const membership = await server.services.projectMembership.deleteProjectMembership({
+        actorId: req.permission.id,
+        actor: req.permission.type,
+        projectId: req.params.workspaceId,
+        membershipId: req.params.membershipId
+      });
+      return { membership };
+    }
+  });
+};

backend-pg/src/server/routes/v1/project-router.ts

@@ -0,0 +1,265 @@
+import { z } from "zod";
+
+import {
+  ProjectKeysSchema,
+  ProjectMembershipsSchema,
+  ProjectsSchema,
+  UserEncryptionKeysSchema,
+  UsersSchema
+} from "@app/db/schemas";
+import { verifyAuth } from "@app/server/plugins/auth/verify-auth";
+import { AuthMode } from "@app/services/auth/auth-type";
+
+export const registerProjectRouter = (server: FastifyZodProvider) => {
+  server.route({
+    url: "/:workspaceId/keys",
+    method: "GET",
+    schema: {
+      params: z.object({
+        workspaceId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          publicKeys: z
+            .object({
+              publicKey: z.string().optional(),
+              userId: z.string()
+            })
+            .array()
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const publicKeys = await server.services.projectKey.getProjectPublicKeys({
+        actorId: req.permission.id,
+        actor: req.permission.type,
+        projectId: req.params.workspaceId
+      });
+      return { publicKeys };
+    }
+  });
+
+  server.route({
+    url: "/:workspaceId/users",
+    method: "GET",
+    schema: {
+      params: z.object({
+        workspaceId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          users: ProjectMembershipsSchema.merge(
+            z.object({
+              user: UsersSchema.pick({
+                email: true,
+                firstName: true,
+                lastName: true,
+                id: true
+              }).merge(UserEncryptionKeysSchema.pick({ publicKey: true }))
+            })
+          )
+            .omit({ createdAt: true, updatedAt: true })
+            .array()
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const users = await server.services.projectMembership.getProjectMemberships({
+        actorId: req.permission.id,
+        actor: req.permission.type,
+        projectId: req.params.workspaceId
+      });
+      return { users };
+    }
+  });
+
+  server.route({
+    url: "/",
+    method: "GET",
+    schema: {
+      response: {
+        200: z.object({
+          workspaces: ProjectsSchema.merge(
+            z.object({ environments: z.object({ name: z.string(), slug: z.string() }).array() })
+          ).array()
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT, AuthMode.API_KEY]),
+    handler: async (req) => {
+      const workspaces = await server.services.project.getProjects(req.permission.id);
+      return { workspaces };
+    }
+  });
+
+  server.route({
+    url: "/:workspaceId",
+    method: "GET",
+    schema: {
+      params: z.object({
+        workspaceId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          workspace: ProjectsSchema.merge(
+            z.object({ environments: z.object({ name: z.string(), slug: z.string() }).array() })
+          ).optional()
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const workspace = await server.services.project.getAProject({
+        actorId: req.permission.id,
+        actor: req.permission.type,
+        projectId: req.params.workspaceId
+      });
+      return { workspace };
+    }
+  });
+
+  server.route({
+    url: "/",
+    method: "POST",
+    schema: {
+      body: z.object({
+        workspaceName: z.string().trim(),
+        organizationId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          workspace: ProjectsSchema
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const workspace = await server.services.project.createProject({
+        actorId: req.permission.id,
+        actor: req.permission.type,
+        orgId: req.body.organizationId,
+        workspaceName: req.body.workspaceName
+      });
+      return { workspace };
+    }
+  });
+
+  server.route({
+    url: "/:workspaceId",
+    method: "DELETE",
+    schema: {
+      params: z.object({
+        workspaceId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          workspace: ProjectsSchema.optional()
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const workspace = await server.services.project.deleteProject({
+        actorId: req.permission.id,
+        actor: req.permission.type,
+        projectId: req.params.workspaceId
+      });
+      return { workspace };
+    }
+  });
+
+  server.route({
+    url: "/:workspaceId/name",
+    method: "POST",
+    schema: {
+      params: z.object({
+        workspaceId: z.string().trim()
+      }),
+      body: z.object({
+        name: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          message: z.string(),
+          workspace: ProjectsSchema
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const workspace = await server.services.project.updateName({
+        actorId: req.permission.id,
+        actor: req.permission.type,
+        projectId: req.params.workspaceId,
+        name: req.body.name
+      });
+      return {
+        message: "Successfully changed workspace name",
+        workspace
+      };
+    }
+  });
+
+  server.route({
+    url: "/:workspaceId/auto-capitalization",
+    method: "POST",
+    schema: {
+      params: z.object({
+        workspaceId: z.string().trim()
+      }),
+      body: z.object({
+        autoCapitalization: z.boolean()
+      }),
+      response: {
+        200: z.object({
+          message: z.string(),
+          workspace: ProjectsSchema
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const workspace = await server.services.project.toggleAutoCapitalization({
+        actorId: req.permission.id,
+        actor: req.permission.type,
+        projectId: req.params.workspaceId,
+        autoCapitalization: req.body.autoCapitalization
+      });
+      return {
+        message: "Successfully changed workspace settings",
+        workspace
+      };
+    }
+  });
+
+  server.route({
+    url: "/:workspaceId/invite-signup",
+    method: "POST",
+    schema: {
+      params: z.object({
+        workspaceId: z.string().trim()
+      }),
+      body: z.object({
+        email: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          invitee: UsersSchema,
+          latestKey: ProjectKeysSchema
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const { invitee, latestKey } = await server.services.projectMembership.inviteUserToProject({
+        actorId: req.permission.id,
+        actor: req.permission.type,
+        projectId: req.params.workspaceId,
+        email: req.body.email
+      });
+      return { invitee, latestKey };
+    }
+  });
+};

backend-pg/src/server/routes/v2/index.ts

@@ -1,7 +1,14 @@
 import { registerMfaRouter } from "./mfa-router";
+import { registerProjectRouter } from "./project-router";
 import { registerUserRouter } from "./user-router";
 
 export const registerV2Routes = async (server: FastifyZodProvider) => {
   await server.register(registerMfaRouter, { prefix: "/auth" });
   await server.register(registerUserRouter, { prefix: "/users" });
+  await server.register(
+    async (projectServer) => {
+      projectServer.register(registerProjectRouter);
+    },
+    { prefix: "/workspace" }
+  );
 };

backend-pg/src/server/routes/v2/project-router.ts

@@ -0,0 +1,35 @@
+import { ProjectKeysSchema } from "@app/db/schemas";
+import { verifyAuth } from "@app/server/plugins/auth/verify-auth";
+import { AuthMode } from "@app/services/auth/auth-type";
+import { z } from "zod";
+
+export const registerProjectRouter = async (server: FastifyZodProvider) => {
+  server.route({
+    url: "/:workspaceId/encrypted-key",
+    method: "GET",
+    schema: {
+      params: z.object({
+        workspaceId: z.string().trim()
+      }),
+      response: {
+        200: ProjectKeysSchema.merge(
+          z.object({
+            sender: z.object({
+              publicKey: z.string()
+            })
+          })
+        )
+      }
+    },
+    onResponse: verifyAuth([AuthMode.JWT, AuthMode.API_KEY]),
+    handler: async (req) => {
+      const key = await server.services.projectKey.getLatestProjectKey({
+        actor: req.permission.type,
+        actorId: req.permission.id,
+        projectId: req.params.workspaceId
+      });
+
+      return key;
+    }
+  });
+};