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

backend-pg/src/@types/fastify.d.ts

@@ -10,6 +10,11 @@ import { AuthMode } from "@app/services/auth/auth-signup-type";
 import { ActorType } from "@app/services/auth/auth-type";
 import { TOrgRoleServiceFactory } from "@app/services/org/org-role-service";
 import { TOrgServiceFactory } from "@app/services/org/org-service";
+import { TProjectServiceFactory } from "@app/services/project/project-service";
+import { TProjectEnvServiceFactory } from "@app/services/project-env/project-env-service";
+import { TProjectKeyServiceFactory } from "@app/services/project-key/project-key-service";
+import { TProjectMembershipServiceFactory } from "@app/services/project-membership/project-membership-service";
+import { TProjectRoleServiceFactory } from "@app/services/project-role/project-role-service";
 import { TSuperAdminServiceFactory } from "@app/services/super-admin/super-admin-service";
 import { TAuthTokenServiceFactory } from "@app/services/token/token-service";
 import { TUserDalFactory } from "@app/services/user/user-dal";
@@ -54,6 +59,11 @@ declare module "fastify" {
       superAdmin: TSuperAdminServiceFactory;
       user: TUserServiceFactory;
       apiKey: TApiKeyServiceFactory;
+      project: TProjectServiceFactory;
+      projectMembership: TProjectMembershipServiceFactory;
+      projectEnv: TProjectEnvServiceFactory;
+      projectKey: TProjectKeyServiceFactory;
+      projectRole: TProjectRoleServiceFactory;
     };
 
     // this is exclusive use for middlewares in which we need to inject data

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

@@ -1,6 +1,8 @@
 import { registerOrgRoleRouter } from "./org-role-router";
+import { registerProjectRoleRouter } from "./project-role-router";
 
 export const registerV1EERoutes = async (server: FastifyZodProvider) => {
   // org role starts with organization
   await server.register(registerOrgRoleRouter, { prefix: "/organization" });
+  await server.register(registerProjectRoleRouter, { prefix: "/workspace" });
 };

backend-pg/src/ee/routes/v1/org-role-router.ts

@@ -16,7 +16,6 @@ export const registerOrgRoleRouter = async (server: FastifyZodProvider) => {
         slug: z.string().trim(),
         name: z.string().trim(),
         description: z.string().trim().optional(),
-        workspaceId: z.string().trim().optional(),
         permissions: z.any().array()
       }),
       response: {
@@ -62,10 +61,7 @@ export const registerOrgRoleRouter = async (server: FastifyZodProvider) => {
         req.auth.userId,
         req.params.organizationId,
         req.params.roleId,
-        {
-          ...req.body,
-          permissions: req.body.permissions ? JSON.stringify(req.body.permissions) : undefined
-        }
+        req.body
       );
       return { role };
     }

backend-pg/src/ee/routes/v1/project-role-router.ts

@@ -0,0 +1,149 @@
+import { z } from "zod";
+
+import { ProjectMembershipsSchema, ProjectRolesSchema } from "@app/db/schemas";
+import { verifyAuth } from "@app/server/plugins/auth/verify-auth";
+import { AuthMode } from "@app/services/auth/auth-type";
+
+export const registerProjectRoleRouter = async (server: FastifyZodProvider) => {
+  server.route({
+    method: "POST",
+    url: "/:projectId/roles",
+    schema: {
+      params: z.object({
+        projectId: z.string().trim()
+      }),
+      body: z.object({
+        slug: z.string().trim(),
+        name: z.string().trim(),
+        description: z.string().trim().optional(),
+        permissions: z.any().array()
+      }),
+      response: {
+        200: z.object({
+          role: ProjectRolesSchema
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const role = await server.services.projectRole.createRole(
+        req.permission.type,
+        req.permission.id,
+        req.params.projectId,
+        req.body
+      );
+      return { role };
+    }
+  });
+
+  server.route({
+    method: "PATCH",
+    url: "/:projectId/roles/:roleId",
+    schema: {
+      params: z.object({
+        projectId: z.string().trim(),
+        roleId: z.string().trim()
+      }),
+      body: z.object({
+        slug: z.string().trim().optional(),
+        name: z.string().trim().optional(),
+        description: z.string().trim().optional(),
+        permissions: z.any().array()
+      }),
+      response: {
+        200: z.object({
+          role: ProjectRolesSchema
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const role = await server.services.projectRole.updateRole(
+        req.permission.type,
+        req.permission.id,
+        req.params.projectId,
+        req.params.roleId,
+        req.body
+      );
+      return { role };
+    }
+  });
+
+  server.route({
+    method: "DELETE",
+    url: "/:projectId/roles/:roleId",
+    schema: {
+      params: z.object({
+        projectId: z.string().trim(),
+        roleId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          role: ProjectRolesSchema
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const role = await server.services.projectRole.deleteRole(
+        req.permission.type,
+        req.permission.id,
+        req.params.projectId,
+        req.params.roleId
+      );
+      return { role };
+    }
+  });
+
+  server.route({
+    method: "GET",
+    url: "/:projectId/roles",
+    schema: {
+      params: z.object({
+        projectId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          data: z.object({
+            roles: ProjectRolesSchema.omit({ permissions: true })
+              .merge(z.object({ permissions: z.unknown() }))
+              .array()
+          })
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const roles = await server.services.projectRole.listRoles(
+        req.permission.type,
+        req.permission.id,
+        req.params.projectId
+      );
+      return { data: { roles } };
+    }
+  });
+
+  server.route({
+    method: "GET",
+    url: "/:projectId/permissions",
+    schema: {
+      params: z.object({
+        projectId: z.string().trim()
+      }),
+      response: {
+        200: z.object({
+          membership: ProjectMembershipsSchema,
+          permissions: z.any().array()
+        })
+      }
+    },
+    onRequest: verifyAuth([AuthMode.JWT]),
+    handler: async (req) => {
+      const { permissions, membership } = await server.services.projectRole.getUserPermission(
+        req.auth.userId,
+        req.params.projectId
+      );
+      return { permissions, membership };
+    }
+  });
+};

backend-pg/src/ee/services/permission/permission-service.ts

@@ -16,7 +16,9 @@ import {
   projectAdminPermissions,
   projectMemberPermissions,
   projectNoAccessPermissions,
-  projectViewerPermission} from "./project-permission";
+  ProjectPermissionSet,
+  projectViewerPermission
+} from "./project-permission";
 
 type TPermissionServiceFactoryDep = {
   permissionDal: TPermissionDalFactory;
@@ -68,9 +70,9 @@ export const permissionServiceFactory = ({ permissionDal }: TPermissionServiceFa
     if (membership.role === ProjectMembershipRole.NoAccess)
       return { permission: projectNoAccessPermissions, membership };
     if (membership.role === ProjectMembershipRole.Custom) {
-      const permission = createMongoAbility<OrgPermissionSet>(
+      const permission = createMongoAbility<ProjectPermissionSet>(
         // akhilmhdh: putting any due to ts incompatiable matching with string and the other
-        unpackRules<RawRuleOf<MongoAbility<OrgPermissionSet>>>(membership.permissions as any),
+        unpackRules<RawRuleOf<MongoAbility<ProjectPermissionSet>>>(membership.permissions as any),
         {
           conditionsMatcher
         }

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;
+    }
+  });
+};

backend-pg/src/services/org/org-role-service.ts

@@ -60,7 +60,10 @@ export const orgRoleServiceFactory = ({
       if (existingRole && existingRole.id !== roleId)
         throw new BadRequestError({ name: "Update Role", message: "Duplicate role" });
     }
-    const [updatedRole] = await orgRoleDal.update({ id: roleId, orgId }, { ...data });
+    const [updatedRole] = await orgRoleDal.update(
+      { id: roleId, orgId },
+      { ...data, permissions: data.permissions ? JSON.stringify(data.permissions) : undefined }
+    );
     if (!updateRole) throw new BadRequestError({ message: "Role not found", name: "Update role" });
     return updatedRole;
   };

backend-pg/src/services/project-key/project-key-dal.ts

@@ -1,5 +1,5 @@
 import { TDbClient } from "@app/db";
-import { TableName,TProjectKeys } from "@app/db/schemas";
+import { TableName, TProjectKeys } from "@app/db/schemas";
 import { DatabaseError } from "@app/lib/errors";
 import { ormify } from "@app/lib/knex";
 
@@ -35,8 +35,26 @@ export const projectKeyDalFactory = (db: TDbClient) => {
     }
   };
 
+  const findAllProjectUserPubKeys = async (projectId: string) => {
+    try {
+      const pubKeys = await db(TableName.ProjectMembership)
+        .where({ projectId })
+        .join(TableName.Users, `${TableName.ProjectMembership}.userId`, `${TableName.Users}.id`)
+        .join(
+          TableName.UserEncryptionKey,
+          `${TableName.Users}.id`,
+          `${TableName.UserEncryptionKey}.userId`
+        )
+        .select("userId", "publicKey");
+      return pubKeys;
+    } catch (error) {
+      throw new DatabaseError({ error, name: "Find all workspace pub keys" });
+    }
+  };
+
   return {
     ...projectKeyOrm,
+    findAllProjectUserPubKeys,
     findLatestProjectKey
   };
 };

backend-pg/src/services/project-key/project-key-service.ts

@@ -57,8 +57,18 @@ export const projectKeyServiceFactory = ({
     return latestKey;
   };
 
+  const getProjectPublicKeys = async ({ actor, actorId, projectId }: TGetLatestProjectKeyDTO) => {
+    const { permission } = await permissionService.getProjectPermission(actor, actorId, projectId);
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Read,
+      ProjectPermissionSub.Member
+    );
+    return projectKeyDal.findAllProjectUserPubKeys(projectId);
+  };
+
   return {
     uploadProjectKeys,
+    getProjectPublicKeys,
     getLatestProjectKey
   };
 };

backend-pg/src/services/project-membership/project-membership-dal.ts

@@ -21,20 +21,18 @@ export const projectMembershipDalFactory = (db: TDbClient) => {
         )
         .select(
           db.ref("id").withSchema(TableName.ProjectMembership),
-          db.ref("inviteEmail").withSchema(TableName.ProjectMembership),
-          db.ref("orgId").withSchema(TableName.ProjectMembership),
+          db.ref("projectId").withSchema(TableName.ProjectMembership),
           db.ref("role").withSchema(TableName.ProjectMembership),
           db.ref("roleId").withSchema(TableName.ProjectMembership),
-          db.ref("status").withSchema(TableName.ProjectMembership),
           db.ref("email").withSchema(TableName.Users),
           db.ref("firstName").withSchema(TableName.Users),
           db.ref("lastName").withSchema(TableName.Users),
           db.ref("id").withSchema(TableName.Users).as("userId"),
           db.ref("publicKey").withSchema(TableName.UserEncryptionKey)
         );
-      return members.map(({ email, firstName, lastName, userId, publicKey, ...data }) => ({
+      return members.map(({ email, firstName, lastName, publicKey, ...data }) => ({
         ...data,
-        user: { email, firstName, lastName, id: userId, publicKey }
+        user: { email, firstName, lastName, id: data.userId, publicKey }
       }));
     } catch (error) {
       throw new DatabaseError({ error, name: "Find all project members" });

backend-pg/src/services/project-membership/project-membership-service.ts

@@ -177,6 +177,7 @@ export const projectMembershipServiceFactory = ({
         tx
       );
       await projectKeyDal.delete({ receiverId: deletedMembership.userId, projectId }, tx);
+      return deletedMembership;
     });
     return membership;
   };

backend-pg/src/services/project-role/project-role-service.ts

@@ -2,15 +2,13 @@ import { ForbiddenError } from "@casl/ability";
 import { packRules } from "@casl/ability/extra";
 
 import { ProjectMembershipRole, TOrgRolesUpdate, TProjectRolesInsert } from "@app/db/schemas";
-import {
-  OrgPermissionActions,
-  OrgPermissionSubjects
-} from "@app/ee/services/permission/org-permission";
 import { TPermissionServiceFactory } from "@app/ee/services/permission/permission-service";
 import {
   projectAdminPermissions,
   projectMemberPermissions,
   projectNoAccessPermissions,
+  ProjectPermissionActions,
+  ProjectPermissionSub,
   projectViewerPermission
 } from "@app/ee/services/permission/project-permission";
 import { BadRequestError } from "@app/lib/errors";
@@ -22,7 +20,7 @@ type TProjectRoleServiceFactoryDep = {
   projectRoleDal: TProjectRoleDalFactory;
   permissionService: Pick<
     TPermissionServiceFactory,
-    "getProjectPermission" | "getUserOrgPermission"
+    "getProjectPermission" | "getUserProjectPermission"
   >;
 };
 
@@ -40,8 +38,8 @@ export const projectRoleServiceFactory = ({
   ) => {
     const { permission } = await permissionService.getProjectPermission(actor, actorId, projectId);
     ForbiddenError.from(permission).throwUnlessCan(
-      OrgPermissionActions.Create,
-      OrgPermissionSubjects.Role
+      ProjectPermissionActions.Create,
+      ProjectPermissionSub.Role
     );
     const existingRole = await projectRoleDal.findOne({ slug: data.slug, projectId });
     if (existingRole) throw new BadRequestError({ name: "Create Role", message: "Duplicate role" });
@@ -62,8 +60,8 @@ export const projectRoleServiceFactory = ({
   ) => {
     const { permission } = await permissionService.getProjectPermission(actor, actorId, projectId);
     ForbiddenError.from(permission).throwUnlessCan(
-      OrgPermissionActions.Edit,
-      OrgPermissionSubjects.Role
+      ProjectPermissionActions.Edit,
+      ProjectPermissionSub.Role
     );
     if (data?.slug) {
       const existingRole = await projectRoleDal.findOne({ slug: data.slug, projectId });
@@ -83,8 +81,8 @@ export const projectRoleServiceFactory = ({
   ) => {
     const { permission } = await permissionService.getProjectPermission(actor, actorId, projectId);
     ForbiddenError.from(permission).throwUnlessCan(
-      OrgPermissionActions.Delete,
-      OrgPermissionSubjects.Role
+      ProjectPermissionActions.Delete,
+      ProjectPermissionSub.Role
     );
     const [deletedRole] = await projectRoleDal.delete({ id: roleId, projectId });
     if (!deleteRole) throw new BadRequestError({ message: "Role not found", name: "Update role" });
@@ -95,8 +93,8 @@ export const projectRoleServiceFactory = ({
   const listRoles = async (actor: ActorType, actorId: string, projectId: string) => {
     const { permission } = await permissionService.getProjectPermission(actor, actorId, projectId);
     ForbiddenError.from(permission).throwUnlessCan(
-      OrgPermissionActions.Read,
-      OrgPermissionSubjects.Role
+      ProjectPermissionActions.Read,
+      ProjectPermissionSub.Role
     );
     const customRoles = await projectRoleDal.find({ projectId });
     const roles = [
@@ -149,8 +147,11 @@ export const projectRoleServiceFactory = ({
     return roles;
   };
 
-  const getUserPermission = async (userId: string, orgId: string) => {
-    const { permission, membership } = await permissionService.getUserOrgPermission(userId, orgId);
+  const getUserPermission = async (userId: string, projectId: string) => {
+    const { permission, membership } = await permissionService.getUserProjectPermission(
+      userId,
+      projectId
+    );
     return { permissions: packRules(permission.rules), membership };
   };
 

backend-pg/src/services/project/project-dal.ts

@@ -1,5 +1,5 @@
 import { TDbClient } from "@app/db";
-import { TableName,TProjects } from "@app/db/schemas";
+import { TableName, TProjects } from "@app/db/schemas";
 import { DatabaseError } from "@app/lib/errors";
 import { mergeOneToManyRelation, ormify } from "@app/lib/knex";
 
@@ -90,27 +90,9 @@ export const projectDalFactory = (db: TDbClient) => {
     }
   };
 
-  const findAllProjectUserPubKeys = async (projectId: string) => {
-    try {
-      const pubKeys = await db(TableName.ProjectMembership)
-        .where({ projectId })
-        .join(TableName.Users, `${TableName.ProjectMembership}.userId`, `${TableName.Users}.id`)
-        .join(
-          TableName.UserEncryptionKey,
-          `${TableName.Users}.id`,
-          `${TableName.UserEncryptionKey}.userId`
-        )
-        .select("userId", "publicKey");
-      return pubKeys;
-    } catch (error) {
-      throw new DatabaseError({ error, name: "Find all workspace pub keys" });
-    }
-  };
-
   return {
     ...projectOrm,
     findAllProjects,
-    findProjectById,
-    findAllProjectUserPubKeys
+    findProjectById
   };
 };

backend-pg/src/services/project/project-service.ts

@@ -103,11 +103,28 @@ export const projectServiceFactory = ({
     return updatedProject;
   };
 
+  const updateName = async ({
+    projectId,
+    actor,
+    actorId,
+    name
+  }: TGetProjectDTO & { name: string }) => {
+    const { permission } = await permissionService.getProjectPermission(actor, actorId, projectId);
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Edit,
+      ProjectPermissionSub.Settings
+    );
+
+    const updatedProject = await projectDal.updateById(projectId, { name });
+    return updatedProject;
+  };
+
   return {
     createProject,
     deleteProject,
     getProjects,
     getAProject,
-    toggleAutoCapitalization
+    toggleAutoCapitalization,
+    updateName
   };
 };