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

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

@@ -18,7 +18,6 @@ import { registerLdapRouter } from "./ldap-router";
 import { registerLicenseRouter } from "./license-router";
 import { registerOidcRouter } from "./oidc-router";
 import { registerOrgRoleRouter } from "./org-role-router";
-import { registerPITRouter } from "./pit-router";
 import { registerProjectRoleRouter } from "./project-role-router";
 import { registerProjectRouter } from "./project-router";
 import { registerRateLimitRouter } from "./rate-limit-router";
@@ -54,7 +53,6 @@ export const registerV1EERoutes = async (server: FastifyZodProvider) => {
     { prefix: "/workspace" }
   );
   await server.register(registerSnapshotRouter, { prefix: "/secret-snapshot" });
-  await server.register(registerPITRouter, { prefix: "/pit" });
   await server.register(registerSecretApprovalPolicyRouter, { prefix: "/secret-approvals" });
   await server.register(registerSecretApprovalRequestRouter, {
     prefix: "/secret-approval-requests"

backend/src/ee/routes/v1/pit-router.ts

@@ -1,416 +0,0 @@
-/* eslint-disable @typescript-eslint/no-base-to-string */
-import { z } from "zod";
-
-import { EventType } from "@app/ee/services/audit-log/audit-log-types";
-import { removeTrailingSlash } from "@app/lib/fn";
-import { readLimit } from "@app/server/config/rateLimiter";
-import { verifyAuth } from "@app/server/plugins/auth/verify-auth";
-import { booleanSchema } from "@app/server/routes/sanitizedSchemas";
-import { AuthMode } from "@app/services/auth/auth-type";
-import { commitChangesResponseSchema, resourceChangeSchema } from "@app/services/folder-commit/folder-commit-schemas";
-
-const commitHistoryItemSchema = z.object({
-  id: z.string(),
-  folderId: z.string(),
-  actorType: z.string(),
-  actorMetadata: z.unknown().optional(),
-  message: z.string().optional().nullable(),
-  commitId: z.string(),
-  createdAt: z.string().or(z.date()),
-  envId: z.string()
-});
-
-const folderStateSchema = z.array(
-  z.object({
-    type: z.string(),
-    id: z.string(),
-    versionId: z.string(),
-    secretKey: z.string().optional(),
-    secretVersion: z.number().optional(),
-    folderName: z.string().optional(),
-    folderVersion: z.number().optional()
-  })
-);
-
-export const registerPITRouter = async (server: FastifyZodProvider) => {
-  // Get commits count for a folder
-  server.route({
-    method: "GET",
-    url: "/commits/count",
-    config: {
-      rateLimit: readLimit
-    },
-    schema: {
-      querystring: z.object({
-        environment: z.string().trim(),
-        path: z.string().trim().default("/").transform(removeTrailingSlash),
-        projectId: z.string().trim()
-      }),
-      response: {
-        200: z.object({
-          count: z.number(),
-          folderId: z.string()
-        })
-      }
-    },
-    onRequest: verifyAuth([AuthMode.JWT]),
-    handler: async (req) => {
-      const result = await server.services.pit.getCommitsCount({
-        actor: req.permission?.type,
-        actorId: req.permission?.id,
-        actorOrgId: req.permission?.orgId,
-        actorAuthMethod: req.permission?.authMethod,
-        projectId: req.query.projectId,
-        environment: req.query.environment,
-        path: req.query.path
-      });
-
-      await server.services.auditLog.createAuditLog({
-        ...req.auditLogInfo,
-        projectId: req.query.projectId,
-        event: {
-          type: EventType.GET_PROJECT_PIT_COMMIT_COUNT,
-          metadata: {
-            environment: req.query.environment,
-            path: req.query.path,
-            commitCount: result.count.toString()
-          }
-        }
-      });
-
-      return result;
-    }
-  });
-
-  // Get all commits for a folder
-  server.route({
-    method: "GET",
-    url: "/commits",
-    config: {
-      rateLimit: readLimit
-    },
-    schema: {
-      querystring: z.object({
-        environment: z.string().trim(),
-        path: z.string().trim().default("/").transform(removeTrailingSlash),
-        projectId: z.string().trim(),
-        offset: z.coerce.number().min(0).default(0),
-        limit: z.coerce.number().min(1).max(100).default(20),
-        search: z.string().trim().optional(),
-        sort: z.enum(["asc", "desc"]).default("desc")
-      }),
-      response: {
-        200: z.object({
-          commits: commitHistoryItemSchema.array(),
-          total: z.number(),
-          hasMore: z.boolean()
-        })
-      }
-    },
-    onRequest: verifyAuth([AuthMode.JWT]),
-    handler: async (req) => {
-      const result = await server.services.pit.getCommitsForFolder({
-        actor: req.permission?.type,
-        actorId: req.permission?.id,
-        actorOrgId: req.permission?.orgId,
-        actorAuthMethod: req.permission?.authMethod,
-        projectId: req.query.projectId,
-        environment: req.query.environment,
-        path: req.query.path,
-        offset: req.query.offset,
-        limit: req.query.limit,
-        search: req.query.search,
-        sort: req.query.sort
-      });
-
-      await server.services.auditLog.createAuditLog({
-        ...req.auditLogInfo,
-        projectId: req.query.projectId,
-        event: {
-          type: EventType.GET_PROJECT_PIT_COMMITS,
-          metadata: {
-            environment: req.query.environment,
-            path: req.query.path,
-            commitCount: result.commits.length.toString(),
-            offset: req.query.offset.toString(),
-            limit: req.query.limit.toString(),
-            search: req.query.search,
-            sort: req.query.sort
-          }
-        }
-      });
-
-      return result;
-    }
-  });
-
-  // Get commit changes for a specific commit
-  server.route({
-    method: "GET",
-    url: "/commits/:commitId/changes",
-    config: {
-      rateLimit: readLimit
-    },
-    schema: {
-      params: z.object({
-        commitId: z.string().trim()
-      }),
-      querystring: z.object({
-        projectId: z.string().trim()
-      }),
-      response: {
-        200: commitChangesResponseSchema
-      }
-    },
-    onRequest: verifyAuth([AuthMode.JWT]),
-    handler: async (req) => {
-      const result = await server.services.pit.getCommitChanges({
-        actor: req.permission?.type,
-        actorId: req.permission?.id,
-        actorOrgId: req.permission?.orgId,
-        actorAuthMethod: req.permission?.authMethod,
-        projectId: req.query.projectId,
-        commitId: req.params.commitId
-      });
-
-      await server.services.auditLog.createAuditLog({
-        ...req.auditLogInfo,
-        projectId: req.query.projectId,
-        event: {
-          type: EventType.GET_PROJECT_PIT_COMMIT_CHANGES,
-          metadata: {
-            commitId: req.params.commitId,
-            changesCount: (result.changes.changes?.length || 0).toString()
-          }
-        }
-      });
-
-      return result;
-    }
-  });
-
-  // Retrieve rollback changes for a commit
-  server.route({
-    method: "GET",
-    url: "/commits/:commitId/compare",
-    config: {
-      rateLimit: readLimit
-    },
-    schema: {
-      params: z.object({
-        commitId: z.string().trim()
-      }),
-      querystring: z.object({
-        folderId: z.string().trim(),
-        environment: z.string().trim(),
-        deepRollback: booleanSchema.default(false),
-        secretPath: z.string().trim().default("/").transform(removeTrailingSlash),
-        projectId: z.string().trim()
-      }),
-      response: {
-        200: z.array(
-          z.object({
-            folderId: z.string(),
-            folderName: z.string(),
-            folderPath: z.string().optional(),
-            changes: z.array(resourceChangeSchema)
-          })
-        )
-      }
-    },
-    onRequest: verifyAuth([AuthMode.JWT]),
-    handler: async (req) => {
-      const result = await server.services.pit.compareCommitChanges({
-        actor: req.permission?.type,
-        actorId: req.permission?.id,
-        actorOrgId: req.permission?.orgId,
-        actorAuthMethod: req.permission?.authMethod,
-        projectId: req.query.projectId,
-        commitId: req.params.commitId,
-        folderId: req.query.folderId,
-        environment: req.query.environment,
-        deepRollback: req.query.deepRollback,
-        secretPath: req.query.secretPath
-      });
-
-      await server.services.auditLog.createAuditLog({
-        ...req.auditLogInfo,
-        projectId: req.query.projectId,
-        event: {
-          type: EventType.PIT_COMPARE_FOLDER_STATES,
-          metadata: {
-            targetCommitId: req.params.commitId,
-            folderId: req.query.folderId,
-            deepRollback: req.query.deepRollback,
-            diffsCount: result.length.toString(),
-            environment: req.query.environment,
-            folderPath: req.query.secretPath
-          }
-        }
-      });
-
-      return result;
-    }
-  });
-
-  // Rollback to a previous commit
-  server.route({
-    method: "POST",
-    url: "/commits/:commitId/rollback",
-    config: {
-      rateLimit: readLimit
-    },
-    schema: {
-      params: z.object({
-        commitId: z.string().trim()
-      }),
-      body: z.object({
-        folderId: z.string().trim(),
-        deepRollback: z.boolean().default(false),
-        message: z.string().max(256).trim().optional(),
-        environment: z.string().trim(),
-        projectId: z.string().trim()
-      }),
-      response: {
-        200: z.object({
-          success: z.boolean(),
-          secretChangesCount: z.number().optional(),
-          folderChangesCount: z.number().optional(),
-          totalChanges: z.number().optional()
-        })
-      }
-    },
-    onRequest: verifyAuth([AuthMode.JWT]),
-    handler: async (req) => {
-      const result = await server.services.pit.rollbackToCommit({
-        actor: req.permission?.type,
-        actorId: req.permission?.id,
-        actorOrgId: req.permission?.orgId,
-        actorAuthMethod: req.permission?.authMethod,
-        projectId: req.body.projectId,
-        commitId: req.params.commitId,
-        folderId: req.body.folderId,
-        deepRollback: req.body.deepRollback,
-        message: req.body.message,
-        environment: req.body.environment
-      });
-
-      await server.services.auditLog.createAuditLog({
-        ...req.auditLogInfo,
-        projectId: req.body.projectId,
-        event: {
-          type: EventType.PIT_ROLLBACK_COMMIT,
-          metadata: {
-            targetCommitId: req.params.commitId,
-            environment: req.body.environment,
-            folderId: req.body.folderId,
-            deepRollback: req.body.deepRollback,
-            message: req.body.message || "Rollback to previous commit",
-            totalChanges: result.totalChanges?.toString() || "0"
-          }
-        }
-      });
-
-      return result;
-    }
-  });
-
-  // Revert commit
-  server.route({
-    method: "POST",
-    url: "/commits/:commitId/revert",
-    config: {
-      rateLimit: readLimit
-    },
-    schema: {
-      params: z.object({
-        commitId: z.string().trim()
-      }),
-      body: z.object({
-        projectId: z.string().trim()
-      }),
-      response: {
-        200: z.object({
-          success: z.boolean(),
-          message: z.string(),
-          originalCommitId: z.string(),
-          revertCommitId: z.string().optional(),
-          changesReverted: z.number().optional()
-        })
-      }
-    },
-    onRequest: verifyAuth([AuthMode.JWT]),
-    handler: async (req) => {
-      const result = await server.services.pit.revertCommit({
-        actor: req.permission?.type,
-        actorId: req.permission?.id,
-        actorOrgId: req.permission?.orgId,
-        actorAuthMethod: req.permission?.authMethod,
-        projectId: req.body.projectId,
-        commitId: req.params.commitId
-      });
-
-      await server.services.auditLog.createAuditLog({
-        ...req.auditLogInfo,
-        projectId: req.body.projectId,
-        event: {
-          type: EventType.PIT_REVERT_COMMIT,
-          metadata: {
-            commitId: req.params.commitId,
-            revertCommitId: result.revertCommitId,
-            changesReverted: result.changesReverted?.toString()
-          }
-        }
-      });
-
-      return result;
-    }
-  });
-
-  // Folder state at commit
-  server.route({
-    method: "GET",
-    url: "/commits/:commitId",
-    config: {
-      rateLimit: readLimit
-    },
-    schema: {
-      params: z.object({
-        commitId: z.string().trim()
-      }),
-      querystring: z.object({
-        folderId: z.string().trim(),
-        projectId: z.string().trim()
-      }),
-      response: {
-        200: folderStateSchema
-      }
-    },
-    onRequest: verifyAuth([AuthMode.JWT]),
-    handler: async (req) => {
-      const result = await server.services.pit.getFolderStateAtCommit({
-        actor: req.permission?.type,
-        actorId: req.permission?.id,
-        actorOrgId: req.permission?.orgId,
-        actorAuthMethod: req.permission?.authMethod,
-        projectId: req.query.projectId,
-        commitId: req.params.commitId
-      });
-
-      await server.services.auditLog.createAuditLog({
-        ...req.auditLogInfo,
-        projectId: req.query.projectId,
-        event: {
-          type: EventType.PIT_GET_FOLDER_STATE,
-          metadata: {
-            commitId: req.params.commitId,
-            folderId: req.query.folderId,
-            resourceCount: result.length.toString()
-          }
-        }
-      });
-
-      return result;
-    }
-  });
-};

backend/src/ee/services/audit-log/audit-log-types.ts

@@ -381,14 +381,6 @@ export enum EventType {
   PROJECT_ASSUME_PRIVILEGE_SESSION_START = "project-assume-privileges-session-start",
   PROJECT_ASSUME_PRIVILEGE_SESSION_END = "project-assume-privileges-session-end",
 
-  GET_PROJECT_PIT_COMMITS = "get-project-pit-commits",
-  GET_PROJECT_PIT_COMMIT_CHANGES = "get-project-pit-commit-changes",
-  GET_PROJECT_PIT_COMMIT_COUNT = "get-project-pit-commit-count",
-  PIT_ROLLBACK_COMMIT = "pit-rollback-commit",
-  PIT_REVERT_COMMIT = "pit-revert-commit",
-  PIT_GET_FOLDER_STATE = "pit-get-folder-state",
-  PIT_COMPARE_FOLDER_STATES = "pit-compare-folder-states",
-
   UPDATE_ORG = "update-org",
 
   CREATE_PROJECT = "create-project",
@@ -2961,78 +2953,6 @@ interface MicrosoftTeamsWorkflowIntegrationUpdateEvent {
   };
 }
 
-interface GetProjectPitCommitsEvent {
-  type: EventType.GET_PROJECT_PIT_COMMITS;
-  metadata: {
-    commitCount: string;
-    environment: string;
-    path: string;
-    offset: string;
-    limit: string;
-    search?: string;
-    sort: string;
-  };
-}
-
-interface GetProjectPitCommitChangesEvent {
-  type: EventType.GET_PROJECT_PIT_COMMIT_CHANGES;
-  metadata: {
-    changesCount: string;
-    commitId: string;
-  };
-}
-
-interface GetProjectPitCommitCountEvent {
-  type: EventType.GET_PROJECT_PIT_COMMIT_COUNT;
-  metadata: {
-    environment: string;
-    path: string;
-    commitCount: string;
-  };
-}
-
-interface PitRollbackCommitEvent {
-  type: EventType.PIT_ROLLBACK_COMMIT;
-  metadata: {
-    targetCommitId: string;
-    folderId: string;
-    deepRollback: boolean;
-    message: string;
-    totalChanges: string;
-    environment: string;
-  };
-}
-
-interface PitRevertCommitEvent {
-  type: EventType.PIT_REVERT_COMMIT;
-  metadata: {
-    commitId: string;
-    revertCommitId?: string;
-    changesReverted?: string;
-  };
-}
-
-interface PitGetFolderStateEvent {
-  type: EventType.PIT_GET_FOLDER_STATE;
-  metadata: {
-    commitId: string;
-    folderId: string;
-    resourceCount: string;
-  };
-}
-
-interface PitCompareFolderStatesEvent {
-  type: EventType.PIT_COMPARE_FOLDER_STATES;
-  metadata: {
-    targetCommitId: string;
-    folderId: string;
-    deepRollback: boolean;
-    diffsCount: string;
-    environment: string;
-    folderPath: string;
-  };
-}
-
 interface OrgUpdateEvent {
   type: EventType.UPDATE_ORG;
   metadata: {
@@ -3356,13 +3276,6 @@ export type Event =
   | MicrosoftTeamsWorkflowIntegrationGetEvent
   | MicrosoftTeamsWorkflowIntegrationListEvent
   | MicrosoftTeamsWorkflowIntegrationUpdateEvent
-  | GetProjectPitCommitsEvent
-  | GetProjectPitCommitChangesEvent
-  | PitRollbackCommitEvent
-  | GetProjectPitCommitCountEvent
-  | PitRevertCommitEvent
-  | PitCompareFolderStatesEvent
-  | PitGetFolderStateEvent
   | OrgUpdateEvent
   | ProjectCreateEvent
   | ProjectUpdateEvent

backend/src/ee/services/permission/default-roles.ts

@@ -5,7 +5,6 @@ import {
   ProjectPermissionApprovalActions,
   ProjectPermissionCertificateActions,
   ProjectPermissionCmekActions,
-  ProjectPermissionCommitsActions,
   ProjectPermissionDynamicSecretActions,
   ProjectPermissionGroupActions,
   ProjectPermissionIdentityActions,
@@ -79,11 +78,6 @@ const buildAdminPermissionRules = () => {
     ProjectPermissionSub.Certificates
   );
 
-  can(
-    [ProjectPermissionCommitsActions.Read, ProjectPermissionCommitsActions.PerformRollback],
-    ProjectPermissionSub.Commits
-  );
-
   can(
     [
       ProjectPermissionSshHostActions.Edit,
@@ -261,11 +255,6 @@ const buildMemberPermissionRules = () => {
     ProjectPermissionSub.SecretImports
   );
 
-  can(
-    [ProjectPermissionCommitsActions.Read, ProjectPermissionCommitsActions.PerformRollback],
-    ProjectPermissionSub.Commits
-  );
-
   can([ProjectPermissionApprovalActions.Read], ProjectPermissionSub.SecretApproval);
   can([ProjectPermissionSecretRotationActions.Read], ProjectPermissionSub.SecretRotation);
 
@@ -435,7 +424,6 @@ const buildViewerPermissionRules = () => {
   can(ProjectPermissionActions.Read, ProjectPermissionSub.SshCertificates);
   can(ProjectPermissionActions.Read, ProjectPermissionSub.SshCertificateTemplates);
   can(ProjectPermissionSecretSyncActions.Read, ProjectPermissionSub.SecretSyncs);
-  can(ProjectPermissionCommitsActions.Read, ProjectPermissionSub.Commits);
 
   return rules;
 };

backend/src/ee/services/permission/project-permission.ts

@@ -17,11 +17,6 @@ export enum ProjectPermissionActions {
   Delete = "delete"
 }
 
-export enum ProjectPermissionCommitsActions {
-  Read = "read",
-  PerformRollback = "perform-rollback"
-}
-
 export enum ProjectPermissionCertificateActions {
   Read = "read",
   Create = "create",
@@ -157,7 +152,6 @@ export enum ProjectPermissionSub {
   SecretRollback = "secret-rollback",
   SecretApproval = "secret-approval",
   SecretRotation = "secret-rotation",
-  Commits = "commits",
   Identity = "identity",
   CertificateAuthorities = "certificate-authorities",
   Certificates = "certificates",
@@ -296,8 +290,7 @@ export type ProjectPermissionSet =
   | [ProjectPermissionActions.Edit, ProjectPermissionSub.Project]
   | [ProjectPermissionActions.Read, ProjectPermissionSub.SecretRollback]
   | [ProjectPermissionActions.Create, ProjectPermissionSub.SecretRollback]
-  | [ProjectPermissionActions.Edit, ProjectPermissionSub.Kms]
-  | [ProjectPermissionCommitsActions, ProjectPermissionSub.Commits];
+  | [ProjectPermissionActions.Edit, ProjectPermissionSub.Kms];
 
 const SECRET_PATH_MISSING_SLASH_ERR_MSG = "Invalid Secret Path; it must start with a '/'";
 const SECRET_PATH_PERMISSION_OPERATOR_SCHEMA = z.union([
@@ -618,12 +611,6 @@ const GeneralPermissionSchema = [
     action: CASL_ACTION_SCHEMA_NATIVE_ENUM(ProjectPermissionKmipActions).describe(
       "Describe what action an entity can take."
     )
-  }),
-  z.object({
-    subject: z.literal(ProjectPermissionSub.Commits).describe("The entity this permission pertains to."),
-    action: CASL_ACTION_SCHEMA_NATIVE_ENUM(ProjectPermissionCommitsActions).describe(
-      "Describe what action an entity can take."
-    )
   })
 ];
 

backend/src/ee/services/pit/pit-service.ts

@@ -1,485 +0,0 @@
-/* eslint-disable no-await-in-loop */
-import { ForbiddenError } from "@casl/ability";
-
-import { ActionProjectType } from "@app/db/schemas";
-import { ProjectPermissionCommitsActions, ProjectPermissionSub } from "@app/ee/services/permission/project-permission";
-import { NotFoundError } from "@app/lib/errors";
-import { logger } from "@app/lib/logger";
-import { ActorAuthMethod, ActorType } from "@app/services/auth/auth-type";
-import { ResourceType, TFolderCommitServiceFactory } from "@app/services/folder-commit/folder-commit-service";
-import {
-  isFolderCommitChange,
-  isSecretCommitChange
-} from "@app/services/folder-commit-changes/folder-commit-changes-dal";
-import { TProjectEnvDALFactory } from "@app/services/project-env/project-env-dal";
-import { TSecretServiceFactory } from "@app/services/secret/secret-service";
-import { TSecretFolderDALFactory } from "@app/services/secret-folder/secret-folder-dal";
-import { TSecretFolderServiceFactory } from "@app/services/secret-folder/secret-folder-service";
-
-import { TPermissionServiceFactory } from "../permission/permission-service";
-
-type TPitServiceFactoryDep = {
-  folderCommitService: TFolderCommitServiceFactory;
-  secretService: Pick<TSecretServiceFactory, "getSecretVersionsV2ByIds" | "getChangeVersions">;
-  folderService: Pick<TSecretFolderServiceFactory, "getFolderById" | "getFolderVersions">;
-  permissionService: Pick<TPermissionServiceFactory, "getProjectPermission">;
-  folderDAL: Pick<TSecretFolderDALFactory, "findSecretPathByFolderIds">;
-  projectEnvDAL: Pick<TProjectEnvDALFactory, "findOne">;
-};
-
-export type TPitServiceFactory = ReturnType<typeof pitServiceFactory>;
-
-export const pitServiceFactory = ({
-  folderCommitService,
-  secretService,
-  folderService,
-  permissionService,
-  folderDAL,
-  projectEnvDAL
-}: TPitServiceFactoryDep) => {
-  const getCommitsCount = async ({
-    actor,
-    actorId,
-    actorOrgId,
-    actorAuthMethod,
-    projectId,
-    environment,
-    path
-  }: {
-    actor: ActorType;
-    actorId: string;
-    actorOrgId: string;
-    actorAuthMethod: ActorAuthMethod;
-    projectId: string;
-    environment: string;
-    path: string;
-  }) => {
-    const result = await folderCommitService.getCommitsCount({
-      actor,
-      actorId,
-      actorOrgId,
-      actorAuthMethod,
-      projectId,
-      environment,
-      path
-    });
-
-    return result;
-  };
-
-  const getCommitsForFolder = async ({
-    actor,
-    actorId,
-    actorOrgId,
-    actorAuthMethod,
-    projectId,
-    environment,
-    path,
-    offset,
-    limit,
-    search,
-    sort
-  }: {
-    actor: ActorType;
-    actorId: string;
-    actorOrgId: string;
-    actorAuthMethod: ActorAuthMethod;
-    projectId: string;
-    environment: string;
-    path: string;
-    offset: number;
-    limit: number;
-    search?: string;
-    sort: "asc" | "desc";
-  }) => {
-    const result = await folderCommitService.getCommitsForFolder({
-      actor,
-      actorId,
-      actorOrgId,
-      actorAuthMethod,
-      projectId,
-      environment,
-      path,
-      offset,
-      limit,
-      search,
-      sort
-    });
-
-    return {
-      commits: result.commits.map((commit) => ({
-        ...commit,
-        commitId: commit.commitId.toString()
-      })),
-      total: result.total,
-      hasMore: result.hasMore
-    };
-  };
-
-  const getCommitChanges = async ({
-    actor,
-    actorId,
-    actorOrgId,
-    actorAuthMethod,
-    projectId,
-    commitId
-  }: {
-    actor: ActorType;
-    actorId: string;
-    actorOrgId: string;
-    actorAuthMethod: ActorAuthMethod;
-    projectId: string;
-    commitId: string;
-  }) => {
-    const changes = await folderCommitService.getCommitChanges({
-      actor,
-      actorId,
-      actorOrgId,
-      actorAuthMethod,
-      projectId,
-      commitId
-    });
-
-    const [folderWithPath] = await folderDAL.findSecretPathByFolderIds(projectId, [changes.folderId]);
-
-    for (const change of changes.changes) {
-      if (isSecretCommitChange(change)) {
-        change.versions = await secretService.getChangeVersions(
-          {
-            secretVersion: change.secretVersion,
-            secretId: change.secretId,
-            id: change.id,
-            isUpdate: change.isUpdate,
-            changeType: change.changeType
-          },
-          (Number.parseInt(change.secretVersion, 10) - 1).toString(),
-          actorId,
-          actor,
-          actorOrgId,
-          actorAuthMethod,
-          changes.envId,
-          projectId,
-          folderWithPath?.path || ""
-        );
-      } else if (isFolderCommitChange(change)) {
-        change.versions = await folderService.getFolderVersions(
-          change,
-          (Number.parseInt(change.folderVersion, 10) - 1).toString(),
-          change.folderChangeId
-        );
-      }
-    }
-
-    return {
-      changes: {
-        ...changes,
-        commitId: changes.commitId.toString()
-      }
-    };
-  };
-
-  const compareCommitChanges = async ({
-    actor,
-    actorId,
-    actorOrgId,
-    actorAuthMethod,
-    projectId,
-    commitId,
-    folderId,
-    environment,
-    deepRollback,
-    secretPath
-  }: {
-    actor: ActorType;
-    actorId: string;
-    actorOrgId: string;
-    actorAuthMethod: ActorAuthMethod;
-    projectId: string;
-    commitId: string;
-    folderId: string;
-    environment: string;
-    deepRollback: boolean;
-    secretPath: string;
-  }) => {
-    const latestCommit = await folderCommitService.getLatestCommit({
-      folderId,
-      actor,
-      actorId,
-      actorOrgId,
-      actorAuthMethod,
-      projectId
-    });
-
-    const targetCommit = await folderCommitService.getCommitById({
-      commitId,
-      actor,
-      actorId,
-      actorOrgId,
-      actorAuthMethod,
-      projectId
-    });
-
-    const env = await projectEnvDAL.findOne({
-      projectId,
-      slug: environment
-    });
-
-    if (!latestCommit) {
-      throw new NotFoundError({ message: "Latest commit not found" });
-    }
-
-    let diffs;
-    if (deepRollback) {
-      diffs = await folderCommitService.deepCompareFolder({
-        targetCommitId: targetCommit.id,
-        envId: env.id,
-        projectId
-      });
-    } else {
-      const folderData = await folderService.getFolderById({
-        actor,
-        actorId,
-        actorOrgId,
-        actorAuthMethod,
-        id: folderId
-      });
-
-      diffs = [
-        {
-          folderId: folderData.id,
-          folderName: folderData.name,
-          folderPath: secretPath,
-          changes: await folderCommitService.compareFolderStates({
-            targetCommitId: commitId,
-            currentCommitId: latestCommit.id
-          })
-        }
-      ];
-    }
-
-    for (const diff of diffs) {
-      for (const change of diff.changes) {
-        // Use discriminated union type checking
-        if (change.type === ResourceType.SECRET) {
-          // TypeScript now knows this is a SecretChange
-          if (change.secretKey && change.secretVersion && change.secretId) {
-            change.versions = await secretService.getChangeVersions(
-              {
-                secretVersion: change.secretVersion,
-                secretId: change.secretId,
-                id: change.id,
-                isUpdate: change.isUpdate,
-                changeType: change.changeType
-              },
-              change.fromVersion || "1",
-              actorId,
-              actor,
-              actorOrgId,
-              actorAuthMethod,
-              env.id,
-              projectId,
-              diff.folderPath || ""
-            );
-          }
-        } else if (change.type === ResourceType.FOLDER) {
-          // TypeScript now knows this is a FolderChange
-          if (change.folderVersion) {
-            change.versions = await folderService.getFolderVersions(change, change.fromVersion || "1", change.id);
-          }
-        }
-      }
-    }
-
-    return diffs;
-  };
-
-  const rollbackToCommit = async ({
-    actor,
-    actorId,
-    actorOrgId,
-    actorAuthMethod,
-    projectId,
-    commitId,
-    folderId,
-    deepRollback,
-    message,
-    environment
-  }: {
-    actor: ActorType;
-    actorId: string;
-    actorOrgId: string;
-    actorAuthMethod: ActorAuthMethod;
-    projectId: string;
-    commitId: string;
-    folderId: string;
-    deepRollback: boolean;
-    message?: string;
-    environment: string;
-  }) => {
-    const { permission: userPermission } = await permissionService.getProjectPermission({
-      actor,
-      actorId,
-      projectId,
-      actorAuthMethod,
-      actorOrgId,
-      actionProjectType: ActionProjectType.SecretManager
-    });
-
-    ForbiddenError.from(userPermission).throwUnlessCan(
-      ProjectPermissionCommitsActions.PerformRollback,
-      ProjectPermissionSub.Commits
-    );
-
-    const latestCommit = await folderCommitService.getLatestCommit({
-      folderId,
-      actor,
-      actorId,
-      actorOrgId,
-      actorAuthMethod,
-      projectId
-    });
-
-    if (!latestCommit) {
-      throw new NotFoundError({ message: "Latest commit not found" });
-    }
-
-    logger.info(`PIT - Attempting to rollback folder ${folderId} from commit ${latestCommit.id} to commit ${commitId}`);
-
-    const targetCommit = await folderCommitService.getCommitById({
-      commitId,
-      actor,
-      actorId,
-      actorAuthMethod,
-      actorOrgId,
-      projectId
-    });
-
-    const env = await projectEnvDAL.findOne({
-      projectId,
-      slug: environment
-    });
-
-    if (!targetCommit || targetCommit.folderId !== folderId || targetCommit.envId !== env.id) {
-      throw new NotFoundError({ message: "Target commit not found" });
-    }
-
-    if (!latestCommit || latestCommit.envId !== env.id) {
-      throw new NotFoundError({ message: "Latest commit not found" });
-    }
-
-    if (deepRollback) {
-      await folderCommitService.deepRollbackFolder(commitId, env.id, actorId, actor, projectId, message);
-      return { success: true };
-    }
-
-    const diff = await folderCommitService.compareFolderStates({
-      currentCommitId: latestCommit.id,
-      targetCommitId: commitId
-    });
-
-    const response = await folderCommitService.applyFolderStateDifferences({
-      differences: diff,
-      actorInfo: {
-        actorType: actor,
-        actorId,
-        message: message || "Rollback to previous commit"
-      },
-      folderId,
-      projectId,
-      reconstructNewFolders: deepRollback
-    });
-
-    return {
-      success: true,
-      secretChangesCount: response.secretChangesCount,
-      folderChangesCount: response.folderChangesCount,
-      totalChanges: response.totalChanges
-    };
-  };
-
-  const revertCommit = async ({
-    actor,
-    actorId,
-    actorOrgId,
-    actorAuthMethod,
-    projectId,
-    commitId
-  }: {
-    actor: ActorType;
-    actorId: string;
-    actorOrgId: string;
-    actorAuthMethod: ActorAuthMethod;
-    projectId: string;
-    commitId: string;
-  }) => {
-    const response = await folderCommitService.revertCommitChanges({
-      commitId,
-      actor,
-      actorId,
-      actorAuthMethod,
-      actorOrgId,
-      projectId
-    });
-
-    return response;
-  };
-
-  const getFolderStateAtCommit = async ({
-    actor,
-    actorId,
-    actorOrgId,
-    actorAuthMethod,
-    projectId,
-    commitId
-  }: {
-    actor: ActorType;
-    actorId: string;
-    actorOrgId: string;
-    actorAuthMethod: ActorAuthMethod;
-    projectId: string;
-    commitId: string;
-  }) => {
-    const commit = await folderCommitService.getCommitById({
-      commitId,
-      actor,
-      actorId,
-      actorOrgId,
-      actorAuthMethod,
-      projectId
-    });
-
-    if (!commit) {
-      throw new NotFoundError({ message: `Commit with ID ${commitId} not found` });
-    }
-
-    const response = await folderCommitService.reconstructFolderState(commitId);
-
-    return response.map((item) => {
-      if (item.type === ResourceType.SECRET) {
-        return {
-          ...item,
-          secretVersion: Number(item.secretVersion)
-        };
-      }
-
-      if (item.type === ResourceType.FOLDER) {
-        return {
-          ...item,
-          folderVersion: Number(item.folderVersion)
-        };
-      }
-
-      return item;
-    });
-  };
-
-  return {
-    getCommitsCount,
-    getCommitsForFolder,
-    getCommitChanges,
-    compareCommitChanges,
-    rollbackToCommit,
-    revertCommit,
-    getFolderStateAtCommit
-  };
-};

backend/src/ee/services/secret-approval-request/secret-approval-request-service.ts

@@ -20,7 +20,6 @@ import { EnforcementLevel } from "@app/lib/types";
 import { triggerWorkflowIntegrationNotification } from "@app/lib/workflow-integrations/trigger-notification";
 import { TriggerFeature } from "@app/lib/workflow-integrations/types";
 import { ActorType } from "@app/services/auth/auth-type";
-import { TFolderCommitServiceFactory } from "@app/services/folder-commit/folder-commit-service";
 import { TKmsServiceFactory } from "@app/services/kms/kms-service";
 import { KmsDataKey } from "@app/services/kms/kms-types";
 import { TMicrosoftTeamsServiceFactory } from "@app/services/microsoft-teams/microsoft-teams-service";
@@ -135,7 +134,6 @@ type TSecretApprovalRequestServiceFactoryDep = {
   licenseService: Pick<TLicenseServiceFactory, "getPlan">;
   projectMicrosoftTeamsConfigDAL: Pick<TProjectMicrosoftTeamsConfigDALFactory, "getIntegrationDetailsByProject">;
   microsoftTeamsService: Pick<TMicrosoftTeamsServiceFactory, "sendNotification">;
-  folderCommitService: Pick<TFolderCommitServiceFactory, "createCommit">;
 };
 
 export type TSecretApprovalRequestServiceFactory = ReturnType<typeof secretApprovalRequestServiceFactory>;
@@ -167,8 +165,7 @@ export const secretApprovalRequestServiceFactory = ({
   projectSlackConfigDAL,
   resourceMetadataDAL,
   projectMicrosoftTeamsConfigDAL,
-  microsoftTeamsService,
-  folderCommitService
+  microsoftTeamsService
 }: TSecretApprovalRequestServiceFactoryDep) => {
   const requestCount = async ({ projectId, actor, actorId, actorOrgId, actorAuthMethod }: TApprovalRequestCountDTO) => {
     if (actor === ActorType.SERVICE) throw new BadRequestError({ message: "Cannot use service token" });
@@ -609,10 +606,6 @@ export const secretApprovalRequestServiceFactory = ({
           ? await fnSecretV2BridgeBulkInsert({
               tx,
               folderId,
-              actor: {
-                actorId,
-                type: actor
-              },
               orgId: actorOrgId,
               inputSecrets: secretCreationCommits.map((el) => ({
                 tagIds: el?.tags.map(({ id }) => id),
@@ -635,18 +628,13 @@ export const secretApprovalRequestServiceFactory = ({
               secretDAL: secretV2BridgeDAL,
               secretVersionDAL: secretVersionV2BridgeDAL,
               secretTagDAL,
-              secretVersionTagDAL: secretVersionTagV2BridgeDAL,
-              folderCommitService
+              secretVersionTagDAL: secretVersionTagV2BridgeDAL
             })
           : [];
         const updatedSecrets = secretUpdationCommits.length
           ? await fnSecretV2BridgeBulkUpdate({
               folderId,
               orgId: actorOrgId,
-              actor: {
-                actorId,
-                type: actor
-              },
               tx,
               inputSecrets: secretUpdationCommits.map((el) => {
                 const encryptedValue =
@@ -680,8 +668,7 @@ export const secretApprovalRequestServiceFactory = ({
               secretVersionDAL: secretVersionV2BridgeDAL,
               secretTagDAL,
               secretVersionTagDAL: secretVersionTagV2BridgeDAL,
-              resourceMetadataDAL,
-              folderCommitService
+              resourceMetadataDAL
             })
           : [];
         const deletedSecret = secretDeletionCommits.length
@@ -689,13 +676,10 @@ export const secretApprovalRequestServiceFactory = ({
               projectId,
               folderId,
               tx,
-              actorId,
-              actorType: actor,
+              actorId: "",
               secretDAL: secretV2BridgeDAL,
               secretQueueService,
-              inputSecrets: secretDeletionCommits.map(({ key }) => ({ secretKey: key, type: SecretType.Shared })),
-              folderCommitService,
-              secretVersionDAL: secretVersionV2BridgeDAL
+              inputSecrets: secretDeletionCommits.map(({ key }) => ({ secretKey: key, type: SecretType.Shared }))
             })
           : [];
         const updatedSecretApproval = await secretApprovalRequestDAL.updateById(

backend/src/ee/services/secret-replication/secret-replication-service.ts

@@ -10,7 +10,6 @@ import { logger } from "@app/lib/logger";
 import { alphaNumericNanoId } from "@app/lib/nanoid";
 import { QueueName, TQueueServiceFactory } from "@app/queue";
 import { ActorType } from "@app/services/auth/auth-type";
-import { TFolderCommitServiceFactory } from "@app/services/folder-commit/folder-commit-service";
 import { TKmsServiceFactory } from "@app/services/kms/kms-service";
 import { KmsDataKey } from "@app/services/kms/kms-types";
 import { TProjectBotServiceFactory } from "@app/services/project-bot/project-bot-service";
@@ -88,7 +87,6 @@ type TSecretReplicationServiceFactoryDep = {
 
   projectBotService: Pick<TProjectBotServiceFactory, "getBotKey">;
   kmsService: Pick<TKmsServiceFactory, "createCipherPairWithDataKey">;
-  folderCommitService: Pick<TFolderCommitServiceFactory, "createCommit">;
 };
 
 export type TSecretReplicationServiceFactory = ReturnType<typeof secretReplicationServiceFactory>;
@@ -134,7 +132,6 @@ export const secretReplicationServiceFactory = ({
   secretVersionV2BridgeDAL,
   secretV2BridgeDAL,
   kmsService,
-  folderCommitService,
   resourceMetadataDAL
 }: TSecretReplicationServiceFactoryDep) => {
   const $getReplicatedSecrets = (
@@ -422,7 +419,7 @@ export const secretReplicationServiceFactory = ({
                     return {
                       op: operation,
                       requestId: approvalRequestDoc.id,
-                      metadata: doc.metadata ? JSON.stringify(doc.metadata) : [],
+                      metadata: doc.metadata,
                       secretMetadata: JSON.stringify(doc.secretMetadata),
                       key: doc.key,
                       encryptedValue: doc.encryptedValue,
@@ -449,12 +446,11 @@ export const secretReplicationServiceFactory = ({
                     tx,
                     secretTagDAL,
                     resourceMetadataDAL,
-                    folderCommitService,
                     secretVersionTagDAL: secretVersionV2TagBridgeDAL,
                     inputSecrets: locallyCreatedSecrets.map((doc) => {
                       return {
                         type: doc.type,
-                        metadata: doc.metadata ? JSON.stringify(doc.metadata) : [],
+                        metadata: doc.metadata,
                         key: doc.key,
                         encryptedValue: doc.encryptedValue,
                         encryptedComment: doc.encryptedComment,
@@ -470,7 +466,6 @@ export const secretReplicationServiceFactory = ({
                     orgId,
                     folderId: destinationReplicationFolderId,
                     secretVersionDAL: secretVersionV2BridgeDAL,
-                    folderCommitService,
                     secretDAL: secretV2BridgeDAL,
                     tx,
                     resourceMetadataDAL,
@@ -484,7 +479,7 @@ export const secretReplicationServiceFactory = ({
                         },
                         data: {
                           type: doc.type,
-                          metadata: doc.metadata ? JSON.stringify(doc.metadata) : [],
+                          metadata: doc.metadata,
                           key: doc.key,
                           encryptedValue: doc.encryptedValue as Buffer,
                           encryptedComment: doc.encryptedComment,

backend/src/ee/services/secret-rotation-v2/secret-rotation-v2-service.ts

@@ -63,7 +63,6 @@ import { TAppConnectionDALFactory } from "@app/services/app-connection/app-conne
 import { decryptAppConnection } from "@app/services/app-connection/app-connection-fns";
 import { TAppConnectionServiceFactory } from "@app/services/app-connection/app-connection-service";
 import { ActorType } from "@app/services/auth/auth-type";
-import { TFolderCommitServiceFactory } from "@app/services/folder-commit/folder-commit-service";
 import { TKmsServiceFactory } from "@app/services/kms/kms-service";
 import { KmsDataKey } from "@app/services/kms/kms-types";
 import { TProjectBotServiceFactory } from "@app/services/project-bot/project-bot-service";
@@ -99,7 +98,7 @@ export type TSecretRotationV2ServiceFactoryDep = {
     TSecretV2BridgeDALFactory,
     "bulkUpdate" | "insertMany" | "deleteMany" | "upsertSecretReferences" | "find" | "invalidateSecretCacheByProjectId"
   >;
-  secretVersionV2BridgeDAL: Pick<TSecretVersionV2DALFactory, "insertMany" | "findLatestVersionMany">;
+  secretVersionV2BridgeDAL: Pick<TSecretVersionV2DALFactory, "insertMany">;
   secretVersionTagV2BridgeDAL: Pick<TSecretVersionV2TagDALFactory, "insertMany">;
   resourceMetadataDAL: Pick<TResourceMetadataDALFactory, "insertMany" | "delete">;
   secretTagDAL: Pick<TSecretTagDALFactory, "saveTagsToSecretV2" | "deleteTagsToSecretV2" | "find">;
@@ -107,7 +106,6 @@ export type TSecretRotationV2ServiceFactoryDep = {
   snapshotService: Pick<TSecretSnapshotServiceFactory, "performSnapshot">;
   queueService: Pick<TQueueServiceFactory, "queuePg">;
   appConnectionDAL: Pick<TAppConnectionDALFactory, "findById" | "update" | "updateById">;
-  folderCommitService: Pick<TFolderCommitServiceFactory, "createCommit">;
 };
 
 export type TSecretRotationV2ServiceFactory = ReturnType<typeof secretRotationV2ServiceFactory>;
@@ -146,7 +144,6 @@ export const secretRotationV2ServiceFactory = ({
   snapshotService,
   keyStore,
   queueService,
-  folderCommitService,
   appConnectionDAL
 }: TSecretRotationV2ServiceFactoryDep) => {
   const $queueSendSecretRotationStatusNotification = async (secretRotation: TSecretRotationV2Raw) => {
@@ -540,12 +537,7 @@ export const secretRotationV2ServiceFactory = ({
             secretVersionDAL: secretVersionV2BridgeDAL,
             secretVersionTagDAL: secretVersionTagV2BridgeDAL,
             secretTagDAL,
-            folderCommitService,
-            resourceMetadataDAL,
-            actor: {
-              type: actor.type,
-              actorId: actor.id
-            }
+            resourceMetadataDAL
           });
 
           await secretRotationV2DAL.insertSecretMappings(
@@ -681,12 +673,7 @@ export const secretRotationV2ServiceFactory = ({
             secretVersionDAL: secretVersionV2BridgeDAL,
             secretVersionTagDAL: secretVersionTagV2BridgeDAL,
             secretTagDAL,
-            folderCommitService,
-            resourceMetadataDAL,
-            actor: {
-              type: actor.type,
-              actorId: actor.id
-            }
+            resourceMetadataDAL
           });
 
           secretsMappingUpdated = true;
@@ -804,9 +791,6 @@ export const secretRotationV2ServiceFactory = ({
             projectId,
             folderId,
             actorId: actor.id, // not actually used since rotated secrets are shared
-            actorType: actor.type,
-            folderCommitService,
-            secretVersionDAL: secretVersionV2BridgeDAL,
             tx
           });
         }
@@ -950,10 +934,6 @@ export const secretRotationV2ServiceFactory = ({
               secretDAL: secretV2BridgeDAL,
               secretVersionDAL: secretVersionV2BridgeDAL,
               secretVersionTagDAL: secretVersionTagV2BridgeDAL,
-              folderCommitService,
-              actor: {
-                type: ActorType.PLATFORM
-              },
               secretTagDAL,
               resourceMetadataDAL
             });

backend/src/ee/services/secret-rotation/secret-rotation-queue/secret-rotation-queue.ts

@@ -14,7 +14,6 @@ import { logger } from "@app/lib/logger";
 import { alphaNumericNanoId } from "@app/lib/nanoid";
 import { QueueJobs, QueueName, TQueueServiceFactory } from "@app/queue";
 import { ActorType } from "@app/services/auth/auth-type";
-import { CommitType, TFolderCommitServiceFactory } from "@app/services/folder-commit/folder-commit-service";
 import { TKmsServiceFactory } from "@app/services/kms/kms-service";
 import { KmsDataKey } from "@app/services/kms/kms-types";
 import { TProjectBotServiceFactory } from "@app/services/project-bot/project-bot-service";
@@ -54,7 +53,6 @@ type TSecretRotationQueueFactoryDep = {
   secretVersionV2BridgeDAL: Pick<TSecretVersionV2DALFactory, "insertMany" | "findLatestVersionMany">;
   telemetryService: Pick<TTelemetryServiceFactory, "sendPostHogEvents">;
   kmsService: Pick<TKmsServiceFactory, "createCipherPairWithDataKey">;
-  folderCommitService: Pick<TFolderCommitServiceFactory, "createCommit">;
 };
 
 // These error should stop the repeatable job and ask user to reconfigure rotation
@@ -79,7 +77,6 @@ export const secretRotationQueueFactory = ({
   telemetryService,
   secretV2BridgeDAL,
   secretVersionV2BridgeDAL,
-  folderCommitService,
   kmsService
 }: TSecretRotationQueueFactoryDep) => {
   const addToQueue = async (rotationId: string, interval: number) => {
@@ -333,7 +330,7 @@ export const secretRotationQueueFactory = ({
             })),
             tx
           );
-          const secretVersions = await secretVersionV2BridgeDAL.insertMany(
+          await secretVersionV2BridgeDAL.insertMany(
             updatedSecrets.map(({ id, updatedAt, createdAt, ...el }) => ({
               ...el,
               actorType: ActorType.PLATFORM,
@@ -341,22 +338,6 @@ export const secretRotationQueueFactory = ({
             })),
             tx
           );
-
-          await folderCommitService.createCommit(
-            {
-              actor: {
-                type: ActorType.PLATFORM
-              },
-              message: "Changed by Secret rotation",
-              folderId: secretVersions[0].folderId,
-              changes: secretVersions.map((sv) => ({
-                type: CommitType.ADD,
-                isUpdate: true,
-                secretVersionId: sv.id
-              }))
-            },
-            tx
-          );
         });
 
         await secretV2BridgeDAL.invalidateSecretCacheByProjectId(secretRotation.projectId);

backend/src/ee/services/secret-snapshot/secret-snapshot-service.ts

@@ -8,7 +8,6 @@ import { InternalServerError, NotFoundError } from "@app/lib/errors";
 import { groupBy } from "@app/lib/fn";
 import { logger } from "@app/lib/logger";
 import { ActorType } from "@app/services/auth/auth-type";
-import { CommitType, TFolderCommitServiceFactory } from "@app/services/folder-commit/folder-commit-service";
 import { TKmsServiceFactory } from "@app/services/kms/kms-service";
 import { KmsDataKey } from "@app/services/kms/kms-types";
 import { TProjectBotServiceFactory } from "@app/services/project-bot/project-bot-service";
@@ -52,8 +51,8 @@ type TSecretSnapshotServiceFactoryDep = {
   snapshotSecretV2BridgeDAL: TSnapshotSecretV2DALFactory;
   snapshotFolderDAL: TSnapshotFolderDALFactory;
   secretVersionDAL: Pick<TSecretVersionDALFactory, "insertMany" | "findLatestVersionByFolderId">;
-  secretVersionV2BridgeDAL: Pick<TSecretVersionV2DALFactory, "insertMany" | "findLatestVersionByFolderId" | "findOne">;
-  folderVersionDAL: Pick<TSecretFolderVersionDALFactory, "findLatestVersionByFolderId" | "insertMany" | "findOne">;
+  secretVersionV2BridgeDAL: Pick<TSecretVersionV2DALFactory, "insertMany" | "findLatestVersionByFolderId">;
+  folderVersionDAL: Pick<TSecretFolderVersionDALFactory, "findLatestVersionByFolderId" | "insertMany">;
   secretDAL: Pick<TSecretDALFactory, "delete" | "insertMany">;
   secretV2BridgeDAL: Pick<TSecretV2BridgeDALFactory, "delete" | "insertMany">;
   secretTagDAL: Pick<TSecretTagDALFactory, "saveTagsToSecret" | "saveTagsToSecretV2">;
@@ -64,7 +63,6 @@ type TSecretSnapshotServiceFactoryDep = {
   licenseService: Pick<TLicenseServiceFactory, "isValidLicense">;
   kmsService: Pick<TKmsServiceFactory, "createCipherPairWithDataKey">;
   projectBotService: Pick<TProjectBotServiceFactory, "getBotKey">;
-  folderCommitService: Pick<TFolderCommitServiceFactory, "createCommit">;
 };
 
 export type TSecretSnapshotServiceFactory = ReturnType<typeof secretSnapshotServiceFactory>;
@@ -86,8 +84,7 @@ export const secretSnapshotServiceFactory = ({
   snapshotSecretV2BridgeDAL,
   secretVersionV2TagBridgeDAL,
   kmsService,
-  projectBotService,
-  folderCommitService
+  projectBotService
 }: TSecretSnapshotServiceFactoryDep) => {
   const projectSecretSnapshotCount = async ({
     environment,
@@ -406,18 +403,6 @@ export const secretSnapshotServiceFactory = ({
           .filter((el) => el.isRotatedSecret)
           .map((el) => el.secretId);
 
-        const deletedSecretsChanges = new Map(); // secretId -> version info
-        const deletedFoldersChanges = new Map(); // folderId -> version info
-        const addedSecretsChanges = new Map(); // secretId -> version info
-        const addedFoldersChanges = new Map(); // folderId -> version info
-        const commitChanges: {
-          type: string;
-          secretVersionId?: string;
-          folderVersionId?: string;
-          isUpdate?: boolean;
-          folderId?: string;
-        }[] = [];
-
         // this will remove all secrets in current folder except rotated secrets which we ignore
         const deletedTopLevelSecs = await secretV2BridgeDAL.delete(
           {
@@ -439,35 +424,7 @@ export const secretSnapshotServiceFactory = ({
           },
           tx
         );
-
-        await Promise.all(
-          deletedTopLevelSecs.map(async (sec) => {
-            const version = await secretVersionV2BridgeDAL.findOne({ secretId: sec.id, version: sec.version }, tx);
-            deletedSecretsChanges.set(sec.id, {
-              id: sec.id,
-              version: sec.version,
-              // Store the version ID if available from the snapshot
-              versionId: version?.id
-            });
-          })
-        );
-
         const deletedTopLevelSecsGroupById = groupBy(deletedTopLevelSecs, (item) => item.id);
-
-        const deletedFoldersData = await folderDAL.delete({ parentId: snapshot.folderId, isReserved: false }, tx);
-
-        await Promise.all(
-          deletedFoldersData.map(async (folder) => {
-            const version = await folderVersionDAL.findOne({ folderId: folder.id, version: folder.version }, tx);
-            deletedFoldersChanges.set(folder.id, {
-              id: folder.id,
-              version: folder.version,
-              // Store the version ID if available
-              versionId: version?.id
-            });
-          })
-        );
-
         // this will remove all secrets and folders on child
         // due to sql foreign key and link list connection removing the folders removes everything below too
         const deletedFolders = await folderDAL.delete({ parentId: snapshot.folderId, isReserved: false }, tx);
@@ -532,21 +489,14 @@ export const secretSnapshotServiceFactory = ({
         });
         await secretTagDAL.saveTagsToSecretV2(secretTagsToBeInsert, tx);
         const folderVersions = await folderVersionDAL.insertMany(
-          folders.map(({ version, name, id, envId, description }) => ({
+          folders.map(({ version, name, id, envId }) => ({
             name,
             version,
             folderId: id,
-            envId,
-            description
+            envId
           })),
           tx
         );
-
-        // Track added folders
-        folderVersions.forEach((fv) => {
-          addedFoldersChanges.set(fv.folderId, fv);
-        });
-
         const userActorId = actor === ActorType.USER ? actorId : undefined;
         const identityActorId = actor !== ActorType.USER ? actorId : undefined;
         const actorType = actor || ActorType.PLATFORM;
@@ -561,11 +511,6 @@ export const secretSnapshotServiceFactory = ({
           })),
           tx
         );
-
-        secretVersions.forEach((sv) => {
-          addedSecretsChanges.set(sv.secretId, sv);
-        });
-
         await secretVersionV2TagBridgeDAL.insertMany(
           secretVersions.flatMap(({ secretId, id }) =>
             secretVerTagToBeInsert?.[secretId]?.length
@@ -577,70 +522,6 @@ export const secretSnapshotServiceFactory = ({
           ),
           tx
         );
-
-        // Compute commit changes
-        // Handle secrets
-        deletedSecretsChanges.forEach((deletedInfo, secretId) => {
-          const addedSecret = addedSecretsChanges.get(secretId);
-          if (addedSecret) {
-            // Secret was deleted and re-added - this is an update only if versions are different
-            if (deletedInfo.versionId !== addedSecret.id) {
-              commitChanges.push({
-                type: CommitType.ADD, // In the commit system, updates are tracked as "add" with isUpdate=true
-                secretVersionId: addedSecret.id,
-                isUpdate: true
-              });
-            }
-            // Remove from addedSecrets since we've handled it
-            addedSecretsChanges.delete(secretId);
-          } else if (deletedInfo.versionId) {
-            // Secret was only deleted
-            commitChanges.push({
-              type: CommitType.DELETE,
-              secretVersionId: deletedInfo.versionId
-            });
-          }
-        });
-        // Add remaining new secrets (not updates)
-        addedSecretsChanges.forEach((addedSecret) => {
-          commitChanges.push({
-            type: CommitType.ADD,
-            secretVersionId: addedSecret.id
-          });
-        });
-
-        // Handle folders
-        deletedFoldersChanges.forEach((deletedInfo, folderId) => {
-          const addedFolder = addedFoldersChanges.get(folderId);
-          if (addedFolder) {
-            // Folder was deleted and re-added - this is an update only if versions are different
-            if (deletedInfo.versionId !== addedFolder.id) {
-              commitChanges.push({
-                type: CommitType.ADD,
-                folderVersionId: addedFolder.id,
-                isUpdate: true
-              });
-            }
-            // Remove from addedFolders since we've handled it
-            addedFoldersChanges.delete(folderId);
-          } else if (deletedInfo.versionId) {
-            // Folder was only deleted
-            commitChanges.push({
-              type: CommitType.DELETE,
-              folderVersionId: deletedInfo.versionId,
-              folderId: deletedInfo.id
-            });
-          }
-        });
-
-        // Add remaining new folders (not updates)
-        addedFoldersChanges.forEach((addedFolder) => {
-          commitChanges.push({
-            type: CommitType.ADD,
-            folderVersionId: addedFolder.id
-          });
-        });
-
         const newSnapshot = await snapshotDAL.create(
           {
             folderId: snapshot.folderId,
@@ -669,22 +550,6 @@ export const secretSnapshotServiceFactory = ({
             })),
           tx
         );
-        if (commitChanges.length > 0) {
-          await folderCommitService.createCommit(
-            {
-              actor: {
-                type: actorType,
-                metadata: {
-                  id: userActorId || identityActorId
-                }
-              },
-              message: "Rollback to snapshot",
-              folderId: snapshot.folderId,
-              changes: commitChanges
-            },
-            tx
-          );
-        }
 
         return { ...newSnapshot, snapshotSecrets, snapshotFolders };
       });
@@ -744,12 +609,11 @@ export const secretSnapshotServiceFactory = ({
       });
       await secretTagDAL.saveTagsToSecret(secretTagsToBeInsert, tx);
       const folderVersions = await folderVersionDAL.insertMany(
-        folders.map(({ version, name, id, envId, description }) => ({
+        folders.map(({ version, name, id, envId }) => ({
           name,
           version,
           folderId: id,
-          envId,
-          description
+          envId
         })),
         tx
       );