Revert "Revert "Revert "feat(PIT): Point In Time Revamp"""

backend/src/services/secret-folder/secret-folder-dal.ts

@@ -488,75 +488,6 @@ export const secretFolderDALFactory = (db: TDbClient) => {
     }
   };
 
-  const findFoldersByRootAndIds = async ({ rootId, folderIds }: { rootId: string; folderIds: string[] }, tx?: Knex) => {
-    try {
-      // First, get all descendant folders of rootId
-      const descendants = await (tx || db.replicaNode())
-        .withRecursive("descendants", (qb) =>
-          qb
-            .select(
-              selectAllTableCols(TableName.SecretFolder),
-              db.raw("0 as depth"),
-              db.raw(`'/' as path`),
-              db.ref(`${TableName.Environment}.slug`).as("environment")
-            )
-            .from(TableName.SecretFolder)
-            .join(TableName.Environment, `${TableName.SecretFolder}.envId`, `${TableName.Environment}.id`)
-            .where(`${TableName.SecretFolder}.id`, rootId)
-            .union((un) => {
-              void un
-                .select(
-                  selectAllTableCols(TableName.SecretFolder),
-                  db.raw("descendants.depth + 1 as depth"),
-                  db.raw(
-                    `CONCAT(
-                      CASE WHEN descendants.path = '/' THEN '' ELSE descendants.path END,
-                      CASE WHEN ${TableName.SecretFolder}."parentId" is NULL THEN '' ELSE CONCAT('/', secret_folders.name) END
-                    )`
-                  ),
-                  db.ref("descendants.environment")
-                )
-                .from(TableName.SecretFolder)
-                .where(`${TableName.SecretFolder}.isReserved`, false)
-                .join("descendants", `${TableName.SecretFolder}.parentId`, "descendants.id");
-            })
-        )
-        .select<(TSecretFolders & { path: string; depth: number; environment: string })[]>("*")
-        .from("descendants")
-        .whereIn(`id`, folderIds)
-        .orderBy("depth")
-        .orderBy(`name`);
-
-      return descendants;
-    } catch (error) {
-      throw new DatabaseError({ error, name: "FindFoldersByRootAndIds" });
-    }
-  };
-
-  const findByParentId = async (parentId: string, tx?: Knex) => {
-    try {
-      const folders = await (tx || db.replicaNode())(TableName.SecretFolder)
-        .where({ parentId })
-        .andWhere({ isReserved: false })
-        .select(selectAllTableCols(TableName.SecretFolder));
-      return folders;
-    } catch (error) {
-      throw new DatabaseError({ error, name: "findByParentId" });
-    }
-  };
-
-  const findByEnvId = async (envId: string, tx?: Knex) => {
-    try {
-      const folders = await (tx || db.replicaNode())(TableName.SecretFolder)
-        .where({ envId })
-        .andWhere({ isReserved: false })
-        .select(selectAllTableCols(TableName.SecretFolder));
-      return folders;
-    } catch (error) {
-      throw new DatabaseError({ error, name: "findByEnvId" });
-    }
-  };
-
   return {
     ...secretFolderOrm,
     update,
@@ -568,9 +499,6 @@ export const secretFolderDALFactory = (db: TDbClient) => {
     findClosestFolder,
     findByProjectId,
     findByMultiEnv,
-    findByEnvsDeep,
-    findByParentId,
-    findByEnvId,
-    findFoldersByRootAndIds
+    findByEnvsDeep
   };
 };

backend/src/services/secret-folder/secret-folder-service.ts

@@ -10,7 +10,6 @@ import { BadRequestError, NotFoundError } from "@app/lib/errors";
 import { OrderByDirection, OrgServiceActor } from "@app/lib/types";
 import { buildFolderPath } from "@app/services/secret-folder/secret-folder-fns";
 
-import { ChangeType, CommitType, TFolderCommitServiceFactory } from "../folder-commit/folder-commit-service";
 import { TProjectDALFactory } from "../project/project-dal";
 import { TProjectEnvDALFactory } from "../project-env/project-env-dal";
 import { TSecretFolderDALFactory } from "./secret-folder-dal";
@@ -30,8 +29,7 @@ type TSecretFolderServiceFactoryDep = {
   snapshotService: Pick<TSecretSnapshotServiceFactory, "performSnapshot">;
   folderDAL: TSecretFolderDALFactory;
   projectEnvDAL: Pick<TProjectEnvDALFactory, "findOne" | "findBySlugs" | "find">;
-  folderVersionDAL: Pick<TSecretFolderVersionDALFactory, "findLatestFolderVersions" | "create" | "insertMany" | "find">;
-  folderCommitService: Pick<TFolderCommitServiceFactory, "createCommit">;
+  folderVersionDAL: TSecretFolderVersionDALFactory;
   projectDAL: Pick<TProjectDALFactory, "findProjectBySlug">;
 };
 
@@ -43,7 +41,6 @@ export const secretFolderServiceFactory = ({
   permissionService,
   projectEnvDAL,
   folderVersionDAL,
-  folderCommitService,
   projectDAL
 }: TSecretFolderServiceFactoryDep) => {
   const createFolder = async ({
@@ -114,33 +111,15 @@ export const secretFolderServiceFactory = ({
           });
           parentFolderId = newFolders.at(-1)?.id as string;
           const docs = await folderDAL.insertMany(newFolders, tx);
-          const folderVersions = await folderVersionDAL.insertMany(
+          await folderVersionDAL.insertMany(
             docs.map((doc) => ({
               name: doc.name,
               envId: doc.envId,
               version: doc.version,
-              folderId: doc.id,
-              description: doc.description
+              folderId: doc.id
             })),
             tx
           );
-          await folderCommitService.createCommit(
-            {
-              actor: {
-                type: actor,
-                metadata: {
-                  id: actorId
-                }
-              },
-              message: "Folder created",
-              folderId: parentFolderId,
-              changes: folderVersions.map((fv) => ({
-                type: CommitType.ADD,
-                folderVersionId: fv.id
-              }))
-            },
-            tx
-          );
         }
       }
 
@@ -148,32 +127,12 @@ export const secretFolderServiceFactory = ({
         { name, envId: env.id, version: 1, parentId: parentFolderId, description },
         tx
       );
-      const folderVersion = await folderVersionDAL.create(
+      await folderVersionDAL.create(
         {
           name: doc.name,
           envId: doc.envId,
           version: doc.version,
-          folderId: doc.id,
-          description: doc.description
-        },
-        tx
-      );
-      await folderCommitService.createCommit(
-        {
-          actor: {
-            type: actor,
-            metadata: {
-              id: actorId
-            }
-          },
-          message: "Folder created",
-          folderId: parentFolderId,
-          changes: [
-            {
-              type: CommitType.ADD,
-              folderVersionId: folderVersion.id
-            }
-          ]
+          folderId: doc.id
         },
         tx
       );
@@ -266,33 +225,12 @@ export const secretFolderServiceFactory = ({
             { name, description },
             tx
           );
-          const folderVersion = await folderVersionDAL.create(
+          await folderVersionDAL.create(
             {
               name: doc.name,
               envId: doc.envId,
               version: doc.version,
-              folderId: doc.id,
-              description: doc.description
-            },
-            tx
-          );
-          await folderCommitService.createCommit(
-            {
-              actor: {
-                type: actor,
-                metadata: {
-                  id: actorId
-                }
-              },
-              message: "Folder updated",
-              folderId: parentFolder.id,
-              changes: [
-                {
-                  type: CommitType.ADD,
-                  isUpdate: true,
-                  folderVersionId: folderVersion.id
-                }
-              ]
+              folderId: doc.id
             },
             tx
           );
@@ -383,33 +321,12 @@ export const secretFolderServiceFactory = ({
         { name, description },
         tx
       );
-      const folderVersion = await folderVersionDAL.create(
+      await folderVersionDAL.create(
         {
           name: doc.name,
           envId: doc.envId,
           version: doc.version,
-          folderId: doc.id,
-          description: doc.description
-        },
-        tx
-      );
-      await folderCommitService.createCommit(
-        {
-          actor: {
-            type: actor,
-            metadata: {
-              id: actorId
-            }
-          },
-          message: "Folder updated",
-          folderId: parentFolder.id,
-          changes: [
-            {
-              type: CommitType.ADD,
-              isUpdate: true,
-              folderVersionId: folderVersion.id
-            }
-          ]
+          folderId: doc.id
         },
         tx
       );
@@ -464,31 +381,7 @@ export const secretFolderServiceFactory = ({
         },
         tx
       );
-
       if (!doc) throw new NotFoundError({ message: `Failed to delete folder with ID '${idOrName}', not found` });
-
-      const folderVersions = await folderVersionDAL.findLatestFolderVersions([doc.id], tx);
-
-      await folderCommitService.createCommit(
-        {
-          actor: {
-            type: actor,
-            metadata: {
-              id: actorId
-            }
-          },
-          message: "Folder deleted",
-          folderId: parentFolder.id,
-          changes: [
-            {
-              type: CommitType.DELETE,
-              folderVersionId: folderVersions[doc.id].id,
-              folderId: doc.id
-            }
-          ]
-        },
-        tx
-      );
       return doc;
     });
 
@@ -772,45 +665,6 @@ export const secretFolderServiceFactory = ({
     return environmentFolders;
   };
 
-  const getFolderVersionsByIds = async ({
-    folderId,
-    folderVersions
-  }: {
-    folderId: string;
-    folderVersions: string[];
-  }) => {
-    const versions = await folderVersionDAL.find({
-      folderId,
-      $in: {
-        version: folderVersions.map((v) => Number.parseInt(v, 10))
-      }
-    });
-    return versions;
-  };
-
-  const getFolderVersions = async (
-    change: {
-      folderVersion?: string;
-      isUpdate?: boolean;
-      changeType?: string;
-    },
-    fromVersion: string,
-    folderId: string
-  ) => {
-    const currentVersion = change.folderVersion || "1";
-    // eslint-disable-next-line no-await-in-loop
-    const versions = await getFolderVersionsByIds({
-      folderId,
-      folderVersions:
-        change.isUpdate || change.changeType === ChangeType.UPDATE ? [currentVersion, fromVersion] : [currentVersion]
-    });
-    return versions.map((v) => ({
-      version: v.version?.toString() || "1",
-      name: v.name,
-      description: v.description
-    }));
-  };
-
   return {
     createFolder,
     updateFolder,
@@ -821,8 +675,6 @@ export const secretFolderServiceFactory = ({
     getProjectFolderCount,
     getFoldersMultiEnv,
     getFoldersDeepByEnvs,
-    getProjectEnvironmentsFolders,
-    getFolderVersionsByIds,
-    getFolderVersions
+    getProjectEnvironmentsFolders
   };
 };

backend/src/services/secret-folder/secret-folder-version-dal.ts

@@ -43,7 +43,7 @@ export const secretFolderVersionDALFactory = (db: TDbClient) => {
       const docs: Array<TSecretFolderVersions & { max: number }> = await (tx || db.replicaNode())(
         TableName.SecretFolderVersion
       )
-        .whereIn(`${TableName.SecretFolderVersion}.folderId`, folderIds)
+        .whereIn("folderId", folderIds)
         .join(
           (tx || db)(TableName.SecretFolderVersion)
             .groupBy("folderId")
@@ -85,8 +85,6 @@ export const secretFolderVersionDALFactory = (db: TDbClient) => {
         .join(TableName.Project, `${TableName.Project}.id`, `${TableName.Environment}.projectId`)
         .join("folder_cte", "folder_cte.id", `${TableName.SecretFolderVersion}.id`)
         .whereRaw(`folder_cte.row_num > ${TableName.Project}."pitVersionLimit"`)
-        // Projects with version >= 3 will require to have all folder versions for PIT
-        .andWhere(`${TableName.Project}.version`, "<", 3)
         .delete();
     } catch (error) {
       throw new DatabaseError({
@@ -97,107 +95,5 @@ export const secretFolderVersionDALFactory = (db: TDbClient) => {
     logger.info(`${QueueName.DailyResourceCleanUp}: pruning secret folder versions completed`);
   };
 
-  // Get latest versions by folderIds
-  const getLatestFolderVersions = async (folderIds: string[], tx?: Knex): Promise<Array<TSecretFolderVersions>> => {
-    if (!folderIds.length) return [];
-
-    const knexInstance = tx || db.replicaNode();
-    return knexInstance(TableName.SecretFolderVersion)
-      .whereIn(`${TableName.SecretFolderVersion}.folderId`, folderIds)
-      .join(
-        knexInstance(TableName.SecretFolderVersion)
-          .groupBy("folderId")
-          .max("version")
-          .select("folderId")
-          .as("latestVersion"),
-        (bd) => {
-          bd.on(`${TableName.SecretFolderVersion}.folderId`, "latestVersion.folderId").andOn(
-            `${TableName.SecretFolderVersion}.version`,
-            "latestVersion.max"
-          );
-        }
-      );
-  };
-
-  // Get specific versions and update with max version
-  const getSpecificFolderVersionsWithLatest = async (
-    versionIds: string[],
-    tx?: Knex
-  ): Promise<Array<TSecretFolderVersions>> => {
-    if (!versionIds.length) return [];
-
-    const knexInstance = tx || db.replicaNode();
-
-    // Get specific versions
-    const specificVersions = await knexInstance(TableName.SecretFolderVersion).whereIn("id", versionIds);
-
-    // Get folderIds from these versions
-    const specificFolderIds = [...new Set(specificVersions.map((v) => v.folderId).filter(Boolean))];
-
-    if (!specificFolderIds.length) return specificVersions;
-
-    // Get max versions for these folderIds
-    const maxVersionsQuery = await knexInstance(TableName.SecretFolderVersion)
-      .whereIn("folderId", specificFolderIds)
-      .groupBy("folderId")
-      .select("folderId")
-      .max("version", { as: "maxVersion" });
-
-    // Create lookup map for max versions
-    const maxVersionMap = maxVersionsQuery.reduce<Record<string, number>>((acc, item) => {
-      if (item.maxVersion) {
-        acc[item.folderId] = item.maxVersion;
-      }
-      return acc;
-    }, {});
-
-    // Replace version with max version
-    return specificVersions.map((version) => ({
-      ...version,
-      version: maxVersionMap[version.folderId] || version.version
-    }));
-  };
-
-  const findByIdsWithLatestVersion = async (folderIds: string[], versionIds?: string[], tx?: Knex) => {
-    try {
-      if (!folderIds.length && (!versionIds || !versionIds.length)) return {};
-
-      // Run both queries in parallel
-      const [latestVersions, specificVersionsWithLatest] = await Promise.all([
-        folderIds.length ? getLatestFolderVersions(folderIds, tx) : [],
-        versionIds?.length ? getSpecificFolderVersionsWithLatest(versionIds, tx) : []
-      ]);
-
-      const allDocs = [...latestVersions, ...specificVersionsWithLatest];
-
-      // Convert array to record with folderId as key
-      return allDocs.reduce<Record<string, TSecretFolderVersions>>(
-        (prev, curr) => ({ ...prev, [curr.folderId || ""]: curr }),
-        {}
-      );
-    } catch (error) {
-      throw new DatabaseError({ error, name: "FindByIdsWithLatestVersion" });
-    }
-  };
-
-  const findLatestVersion = async (folderId: string, tx?: Knex) => {
-    try {
-      const doc = await (tx || db.replicaNode())(TableName.SecretFolderVersion)
-        .where(`${TableName.SecretFolderVersion}.folderId`, folderId)
-        .select(selectAllTableCols(TableName.SecretFolderVersion))
-        .first();
-      return doc;
-    } catch (error) {
-      throw new DatabaseError({ error, name: "findLatestVersion" });
-    }
-  };
-
-  return {
-    ...secretFolderVerOrm,
-    findLatestFolderVersions,
-    findLatestVersionByFolderId,
-    pruneExcessVersions,
-    findByIdsWithLatestVersion,
-    findLatestVersion
-  };
+  return { ...secretFolderVerOrm, findLatestFolderVersions, findLatestVersionByFolderId, pruneExcessVersions };
 };