feat: changed backend-pg to backend

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

@@ -0,0 +1,60 @@
+import { TDbClient } from "@app/db";
+import { TableName, TProjectKeys } from "@app/db/schemas";
+import { DatabaseError } from "@app/lib/errors";
+import { ormify } from "@app/lib/knex";
+
+export type TProjectKeyDALFactory = ReturnType<typeof projectKeyDALFactory>;
+
+export const projectKeyDALFactory = (db: TDbClient) => {
+  const projectKeyOrm = ormify(db, TableName.ProjectKeys);
+
+  const findLatestProjectKey = async (
+    userId: string,
+    projectId: string
+  ): Promise<TProjectKeys & { sender: { publicKey: string } }> => {
+    try {
+      const projectKey = await db(TableName.ProjectKeys)
+        .where({ projectId, receiverId: userId })
+        .join(TableName.Users, `${TableName.ProjectKeys}.senderId`, `${TableName.Users}.id`)
+        .join(
+          TableName.UserEncryptionKey,
+          `${TableName.UserEncryptionKey}.userId`,
+          `${TableName.Users}.id`
+        )
+        .orderBy("createdAt", "desc", "last")
+        .select(`${TableName.ProjectKeys}.*`, `${TableName.UserEncryptionKey}.publicKey`)
+        .first();
+      if (projectKey) {
+        projectKey.sender = {
+          publicKey: projectKey.publicKey
+        };
+      }
+      return projectKey;
+    } catch (error) {
+      throw new DatabaseError({ error, name: "Find latest project key" });
+    }
+  };
+
+  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/src/services/project-key/project-key-service.ts

@@ -0,0 +1,74 @@
+import { ForbiddenError } from "@casl/ability";
+
+import { TPermissionServiceFactory } from "@app/ee/services/permission/permission-service";
+import {
+  ProjectPermissionActions,
+  ProjectPermissionSub
+} from "@app/ee/services/permission/project-permission";
+import { BadRequestError } from "@app/lib/errors";
+
+import { TProjectMembershipDALFactory } from "../project-membership/project-membership-dal";
+import { TProjectKeyDALFactory } from "./project-key-dal";
+import { TGetLatestProjectKeyDTO, TUploadProjectKeyDTO } from "./project-key-types";
+
+type TProjectKeyServiceFactoryDep = {
+  permissionService: TPermissionServiceFactory;
+  projectKeyDAL: TProjectKeyDALFactory;
+  projectMembershipDAL: TProjectMembershipDALFactory;
+};
+
+export type TProjectKeyServiceFactory = ReturnType<typeof projectKeyServiceFactory>;
+
+export const projectKeyServiceFactory = ({
+  projectKeyDAL,
+  projectMembershipDAL,
+  permissionService
+}: TProjectKeyServiceFactoryDep) => {
+  const uploadProjectKeys = async ({
+    receiverId,
+    actor,
+    actorId,
+    projectId,
+    nonce,
+    encryptedKey
+  }: TUploadProjectKeyDTO) => {
+    const { permission } = await permissionService.getProjectPermission(actor, actorId, projectId);
+    ForbiddenError.from(permission).throwUnlessCan(
+      ProjectPermissionActions.Edit,
+      ProjectPermissionSub.Member
+    );
+
+    const receiverMembership = await projectMembershipDAL.findOne({
+      userId: receiverId,
+      projectId
+    });
+    if (!receiverMembership)
+      throw new BadRequestError({
+        message: "Failed to validate receiver membership",
+        name: "Upload project keys"
+      });
+
+    await projectKeyDAL.create({ projectId, receiverId, encryptedKey, nonce, senderId: actorId });
+  };
+
+  const getLatestProjectKey = async ({ actorId, projectId, actor }: TGetLatestProjectKeyDTO) => {
+    await permissionService.getProjectPermission(actor, actorId, projectId);
+    const latestKey = await projectKeyDAL.findLatestProjectKey(actorId, projectId);
+    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/src/services/project-key/project-key-types.ts

@@ -0,0 +1,9 @@
+import { TProjectPermission } from "@app/lib/types";
+
+export type TGetLatestProjectKeyDTO = TProjectPermission;
+
+export type TUploadProjectKeyDTO = {
+  encryptedKey: string;
+  nonce: string;
+  receiverId: string;
+} & TProjectPermission;