Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

fix(reminders): reap reminders and alerts on bulk and org delete

Calvin276082764dee
diff --git a/backend/src/services/org/org-service.ts b/backend/src/services/org/org-service.ts
index e4b2f7092a..33648d6761 100644
--- a/backend/src/services/org/org-service.ts
+++ b/backend/src/services/org/org-service.ts
@@ -140,7 +140,7 @@ type TOrgServiceFactoryDep = {
>;
projectBotService: Pick<TProjectBotServiceFactory, "getBotKey">;
loginService: Pick<TAuthLoginFactory, "generateUserTokens">;
- reminderService: Pick<TReminderServiceFactory, "deleteReminderBySecretId">;
+ reminderService: Pick<TReminderServiceFactory, "deleteReminderBySecretId" | "deleteRemindersByProjectId">;
userGroupMembershipDAL: TUserGroupMembershipDALFactory;
additionalPrivilegeDAL: TAdditionalPrivilegeDALFactory;
approvalPolicyDAL: Pick<TApprovalPolicyDALFactory, "deleteUserStepApproversInProjects">;
@@ -874,13 +874,11 @@ export const orgServiceFactory = ({
const projects = await projectDAL.find({ orgId }, { tx });
for await (const project of projects) {
- await fnDeleteProjectSecretReminders(project.id, {
- secretDAL,
- secretV2BridgeDAL,
- reminderService,
- projectBotService,
- folderDAL
- });
+ await fnDeleteProjectSecretReminders(
+ project.id,
+ { secretDAL, reminderService, projectBotService, folderDAL },
+ tx
+ );
}
const deletedOrg = await orgDAL.deleteById(orgId, tx);
diff --git a/backend/src/services/reminder/reminder-dal.ts b/backend/src/services/reminder/reminder-dal.ts
index 0f61cc0bfa..efdf04b65d 100644
--- a/backend/src/services/reminder/reminder-dal.ts
+++ b/backend/src/services/reminder/reminder-dal.ts
@@ -58,6 +58,21 @@ export const reminderDALFactory = (db: TDbClient) => {
return reminders.map((reminder) => RemindersSchema.parse(reminder));
};
+ const findSecretIdsByProjectId = async (projectId: string, tx?: Knex) => {
+ const rows = await (tx || db.replicaNode())(TableName.Reminder)
+ .whereNotNull(`${TableName.Reminder}.secretId`)
+ .join<TSecretsV2>(TableName.SecretV2, `${TableName.Reminder}.secretId`, `${TableName.SecretV2}.id`)
+ .join<TSecretFolders>(TableName.SecretFolder, `${TableName.SecretV2}.folderId`, `${TableName.SecretFolder}.id`)
+ .join<TProjectEnvironments>(
+ TableName.Environment,
+ `${TableName.SecretFolder}.envId`,
+ `${TableName.Environment}.id`
+ )
+ .where(`${TableName.Environment}.projectId`, projectId)
+ .select(db.ref("secretId").withSchema(TableName.Reminder));
+ return rows.map((row) => row.secretId as string);
+ };
+
const findByProjectAndDateRange = async (
{
projectId,
@@ -107,6 +122,7 @@ export const reminderDALFactory = (db: TDbClient) => {
return {
...reminderOrm,
+ findSecretIdsByProjectId,
findDueReminders,
findByIdForUpdate,
findSecretReminder,
diff --git a/backend/src/services/reminder/reminder-service.test.ts b/backend/src/services/reminder/reminder-service.test.ts
index 284da17383..e8323c677b 100644
--- a/backend/src/services/reminder/reminder-service.test.ts
+++ b/backend/src/services/reminder/reminder-service.test.ts
@@ -437,3 +437,41 @@ describe("reminder alert sync", () => {
expect(reminders["secret-1"].recipients).toEqual(["user-1"]);
});
});
+
+describe("deleteRemindersByProjectId", () => {
+ test("removes every reminder in the project along with its alerts, in the caller's transaction", async () => {
+ const tx = { tx: "org-delete" } as never;
+ const deleted: unknown[] = [];
+ const reaped: unknown[] = [];
+ const invalidated: string[] = [];
+ const service = reminderServiceFactory({
+ reminderDAL: {
+ findSecretIdsByProjectId: async () => ["secret-1", "secret-2"],
+ delete: async (filter: unknown, trx: unknown) => {
+ deleted.push({ filter, trx });
+ }
+ },
+ alertService: {
+ deleteAlertsForDeletedResources: async (input: unknown, trx: unknown) => {
+ reaped.push({ input, trx });
+ }
+ },
+ secretV2BridgeDAL: {
+ invalidateSecretCacheByProjectId: async (projectId: string) => {
+ invalidated.push(projectId);
+ }
+ }
+ } as never);
+
+ await service.deleteRemindersByProjectId("proj-1", tx);
+
+ expect(deleted).toEqual([{ filter: { $in: { secretId: ["secret-1", "secret-2"] } }, trx: tx }]);
+ expect(reaped).toEqual([
+ {
+ input: { resourceType: SECRET_REMINDER_RESOURCE_TYPE, resourceIds: ["secret-1", "secret-2"] },
+ trx: tx
+ }
+ ]);
+ expect(invalidated).toEqual(["proj-1"]);
+ });
+});
diff --git a/backend/src/services/reminder/reminder-service.ts b/backend/src/services/reminder/reminder-service.ts
index 9cc26fe3d1..53b74423ba 100644
--- a/backend/src/services/reminder/reminder-service.ts
+++ b/backend/src/services/reminder/reminder-service.ts
@@ -7,6 +7,7 @@ import { throwIfMissingSecretReadValueOrDescribePermission } from "@app/ee/servi
import { TPermissionServiceFactory } from "@app/ee/services/permission/permission-service-types";
import { ProjectPermissionSecretActions, ProjectPermissionSub } from "@app/ee/services/permission/project-permission";
import { BadRequestError, NotFoundError } from "@app/lib/errors";
+import { chunkArray } from "@app/lib/fn";
import { logger } from "@app/lib/logger";
import { TChannelRecipientInput } from "../alert/alert-channel-service-types";
@@ -350,6 +351,21 @@ export const reminderServiceFactory = ({
await secretV2BridgeDAL.invalidateSecretCacheByProjectId(projectId);
};
+ const deleteRemindersByProjectId: TReminderServiceFactory["deleteRemindersByProjectId"] = async (
+ projectId: string,
+ tx?: Knex
+ ) => {
+ const secretIds = await reminderDAL.findSecretIdsByProjectId(projectId, tx);
+ for (const ids of chunkArray(secretIds, ORPHAN_REAP_BATCH_SIZE)) {
+ await reminderDAL.delete({ $in: { secretId: ids } }, tx);
+ await alertService.deleteAlertsForDeletedResources(
+ { resourceType: SECRET_REMINDER_RESOURCE_TYPE, resourceIds: ids },
+ tx
+ );
+ }
+ if (secretIds.length > 0) await secretV2BridgeDAL.invalidateSecretCacheByProjectId(projectId);
+ };
+
const deleteReminder: TReminderServiceFactory["deleteReminder"] = async ({
actor,
actorId,
@@ -476,6 +492,7 @@ export const reminderServiceFactory = ({
reapOrphanedReminderAlerts,
deleteReminder,
deleteReminderBySecretId,
+ deleteRemindersByProjectId,
moveReminders,
copyReminders,
getRemindersForDashboard
diff --git a/backend/src/services/reminder/reminder-types.ts b/backend/src/services/reminder/reminder-types.ts
index 74ff9ce01e..b2f5c79e55 100644
--- a/backend/src/services/reminder/reminder-types.ts
+++ b/backend/src/services/reminder/reminder-types.ts
@@ -94,6 +94,8 @@ export interface TReminderServiceFactory {
deleteReminderBySecretId: (secretId: string, projectId: string, tx?: Knex) => Promise<void>;
+ deleteRemindersByProjectId: (projectId: string, tx?: Knex) => Promise<void>;
+
moveReminders: (moves: TReminderMove[], tx: Knex) => Promise<void>;
copyReminders: (moves: TReminderMove[], tx: Knex) => Promise<void>;
diff --git a/backend/src/services/secret-v2-bridge/secret-v2-bridge-fns.test.ts b/backend/src/services/secret-v2-bridge/secret-v2-bridge-fns.test.ts
index be86383fee..e27d71d59f 100644
--- a/backend/src/services/secret-v2-bridge/secret-v2-bridge-fns.test.ts
+++ b/backend/src/services/secret-v2-bridge/secret-v2-bridge-fns.test.ts
@@ -1,317 +1,31 @@
-import { beforeEach, describe, expect, test, vi } from "vitest";
-
-import { TSecretFolders } from "@app/db/schemas";
-import { ClientClosedRequestError } from "@app/lib/errors";
-import { logger } from "@app/lib/logger";
-
-import { buildHierarchy, expandSecretReferencesGroupedByPath, generatePaths } from "./secret-v2-bridge-fns";
-
-vi.mock("@app/lib/logger", () => ({
- logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() }
-}));
-
-type TPath = { path: string; folderId: string };
-
-const folder = (id: string, name: string, parentId: string | null) =>
- ({
- id,
- name,
- parentId,
- envId: "env-1",
- version: 1,
- isReserved: false,
- createdAt: new Date(0),
- updatedAt: new Date(0)
- }) as TSecretFolders;
-
-const ROOT = folder("root-id", "root", null);
-
-const buildChain = (depth: number) => {
- const folders = [ROOT];
- let parent = ROOT.id;
- for (let i = 0; i < depth; i += 1) {
- const id = `d-${i}`;
- folders.push(folder(id, `level-${i}`, parent));
- parent = id;
- }
- return folders;
-};
-
-// Paths for d-0..d-(count-1) of buildChain, rooted at the environment root.
-const chainPaths = (count: number): TPath[] => {
- const paths: TPath[] = [{ path: "/", folderId: ROOT.id }];
- let current = "/";
- for (let i = 0; i < count; i += 1) {
- current = `${current}/level-${i}`;
- paths.push({ path: current, folderId: `d-${i}` });
- }
- return paths;
-};
-
-// Park-Miller PRNG so the random tree is reproducible across runs.
-const seededRandom = (seed: number) => {
- let state = seed;
- return () => {
- state = (state * 16807) % 2147483647;
- return (state - 1) / 2147483646;
- };
-};
-
-const buildRandomTree = (size: number, seed: number) => {
- const rand = seededRandom(seed);
- const folders = [ROOT];
- for (let i = 0; i < size; i += 1) {
- const parent = folders[Math.floor(rand() * folders.length)];
- folders.push(folder(`r-${i}`, `n-${i}`, parent.id));
- }
- // Shuffle so sibling order comes from input order, not creation order.
- for (let i = folders.length - 1; i > 0; i -= 1) {
- const j = Math.floor(rand() * (i + 1));
- [folders[i], folders[j]] = [folders[j], folders[i]];
- }
- return folders;
-};
-
-describe("generatePaths", () => {
- beforeEach(() => {
- vi.mocked(logger.info).mockClear();
- });
-
- test("returns an empty list for an environment with no folders", () => {
- expect(generatePaths(buildHierarchy([]))).toEqual([]);
- });
-
- test("emits the root as '/' and its descendants with a double slash", () => {
- const map = buildHierarchy([ROOT, folder("a", "a", ROOT.id), folder("b", "b", "a")]);
- expect(generatePaths(map)).toEqual([
- { path: "/", folderId: "root-id" },
- { path: "//a", folderId: "a" },
- { path: "//a/b", folderId: "b" }
- ]);
- });
-
- test("emits parent then subtree, in children order (depth-first pre-order)", () => {
- const map = buildHierarchy([
- ROOT,
- folder("a", "a", ROOT.id),
- folder("b", "b", ROOT.id),
- folder("a1", "a1", "a"),
- folder("b1", "b1", "b"),
- folder("a2", "a2", "a")
- ]);
- expect(generatePaths(map).map((p) => p.folderId)).toEqual(["root-id", "a", "a1", "a2", "b", "b1"]);
- });
-
- test("returns every folder of a wide tree in pre-order", () => {
- const width = 500;
- const grandchildren = 4;
- const folders = [ROOT];
- const expected: TPath[] = [{ path: "/", folderId: ROOT.id }];
- for (let i = 0; i < width; i += 1) {
- folders.push(folder(`c-${i}`, `child-${i}`, ROOT.id));
- expected.push({ path: `//child-${i}`, folderId: `c-${i}` });
- for (let j = 0; j < grandchildren; j += 1) {
- folders.push(folder(`g-${i}-${j}`, `grandchild-${j}`, `c-${i}`));
- expected.push({ path: `//child-${i}/grandchild-${j}`, folderId: `g-${i}-${j}` });
- }
- }
-
- expect(generatePaths(buildHierarchy(folders))).toEqual(expected);
- expect(logger.info).not.toHaveBeenCalled();
- });
-
- test("returns a deep tree within the limit in full", () => {
- expect(generatePaths(buildHierarchy(buildChain(19)))).toEqual(chainPaths(19));
- expect(logger.info).not.toHaveBeenCalled();
- });
-
- test("does not log when the deepest folders sit at the limit with nothing below them", () => {
- expect(generatePaths(buildHierarchy(buildChain(20)))).toEqual(chainPaths(20));
- expect(logger.info).not.toHaveBeenCalled();
- });
-
- test("stops at depth 20 on a tree deeper than 20 levels and logs counts, not the folder map", () => {
- const folders = buildChain(35);
- // Extra branches around the cutoff so several folders sit exactly at the limit.
- folders.push(folder("side-17", "side", "d-17"), folder("side-18", "side", "d-18"), folder("side-19", "x", "d-19"));
-
- const actual = generatePaths(buildHierarchy(folders));
-
- // Root is depth 0, so d-19 (depth 20) is the last level emitted and its children are cut.
- const ids = actual.map((p) => p.folderId);
- expect(ids).toEqual(expect.arrayContaining(["d-19", "side-17", "side-18"]));
- expect(ids).not.toContain("d-20");
- expect(ids).not.toContain("side-19");
- expect(actual).toHaveLength(1 + 20 + 2);
-
- // d-19 and side-18 both sit at the limit, but only d-19 has children that get skipped.
- expect(logger.info).toHaveBeenCalledTimes(1);
- const [[message]] = vi.mocked(logger.info).mock.calls as unknown as [[string]];
- expect(message).toContain("[depthLimitedFolderCount=1]");
- expect(message).toContain("[sampleFolderIds=d-19]");
- expect(message).not.toContain("level-");
- expect(message.length).toBeLessThan(500);
- });
-
- test("emits each reachable folder once, under its parent's path, before its own subtree", () => {
- for (const seed of [1, 7, 42, 1337]) {
- const folders = buildRandomTree(3000, seed);
- const byId = new Map(folders.map((f) => [f.id, f]));
- const paths = generatePaths(buildHierarchy(folders));
-
- expect(paths).toHaveLength(folders.length);
- expect(new Set(paths.map((p) => p.folderId)).size).toBe(folders.length);
-
- const indexById = new Map(paths.map((p, i) => [p.folderId, i]));
- const pathById = new Map(paths.map((p) => [p.folderId, p.path]));
- for (const { folderId, path } of paths) {
- const { parentId, name } = byId.get(folderId) as TSecretFolders;
- if (!parentId) {
- expect(path).toBe("/");
- } else {
- expect(path).toBe(`${pathById.get(parentId)}/${name}`);
- expect(indexById.get(parentId)).toBeLessThan(indexById.get(folderId) as number);
- }
- }
- }
- });
-
- test("treats top-level folders not named root as '/<name>'", () => {
- const map = buildHierarchy([folder("x", "x", null), folder("y", "y", "x"), ROOT, folder("z", "z", ROOT.id)]);
- expect(generatePaths(map)).toEqual([
- { path: "/x", folderId: "x" },
- { path: "/x/y", folderId: "y" },
- { path: "/", folderId: "root-id" },
- { path: "//z", folderId: "z" }
- ]);
- });
-
- test("ignores folders that are unreachable from the top level, including parent cycles", () => {
- const map = buildHierarchy([ROOT, folder("p", "p", "q"), folder("q", "q", "p")]);
- expect(generatePaths(map)).toEqual([{ path: "/", folderId: "root-id" }]);
- });
-
- test("honors explicit parentId, basePath and depth arguments", () => {
- const map = buildHierarchy(buildChain(30));
- // Starting at depth 5 below d-2, d-18 lands on the depth-20 limit.
- const expected: TPath[] = [];
- let current = "/base";
- for (let i = 3; i <= 18; i += 1) {
- current = `${current}/level-${i}`;
- expected.push({ path: current, folderId: `d-${i}` });
- }
- expect(generatePaths(map, "d-2", "/base", 5)).toEqual(expected);
- });
-});
-
-type TTestSecret = {
- secretKey: string;
- secretPath: string;
- secretValue: string;
- skipMultilineEncoding?: boolean | null;
-};
-
-describe("expandSecretReferencesGroupedByPath", () => {
- const makeSecret = (secretPath: string, secretKey: string, secretValue = `ref-${secretKey}`): TTestSecret => ({
- secretPath,
- secretKey,
- secretValue
- });
-
- test("expands every secret in place and reports no errors when all expansions succeed", async () => {
- const secrets = [makeSecret("/a", "A1"), makeSecret("/b", "B1"), makeSecret("/a", "A2")];
- const expand = vi.fn(async ({ secretKey }: { secretKey: string }) => `expanded-${secretKey}`);
-
- const errors = await expandSecretReferencesGroupedByPath({
- secrets,
- environment: "dev",
- expandSecretReferences: expand
- });
-
- expect(errors).toEqual([]);
- expect(secrets.map((s) => s.secretValue)).toEqual(["expanded-A1", "expanded-B1", "expanded-A2"]);
- expect(expand).toHaveBeenCalledWith(
- expect.objectContaining({ secretKey: "B1", secretPath: "/b", environment: "dev", value: "ref-B1" })
- );
- });
-
- test("stores an empty string when the expander returns undefined", async () => {
- const secrets = [makeSecret("/a", "A1")];
- await expandSecretReferencesGroupedByPath({
- secrets,
- environment: "dev",
- expandSecretReferences: async () => undefined
- });
- expect(secrets[0].secretValue).toBe("");
- });
-
- test("attributes each rejection to the path of the secret that failed", async () => {
- // Interleaved paths so group order differs from input order.
- const secrets = [
- makeSecret("/a", "A1"),
- makeSecret("/b", "B1"),
- makeSecret("/c", "C1"),
- makeSecret("/a", "A2"),
- makeSecret("/c", "C2"),
- makeSecret("/b", "B2")
- ];
- const failing = new Set(["B2", "C1", "C2"]);
-
- const errors = await expandSecretReferencesGroupedByPath({
- secrets,
- environment: "dev",
- expandSecretReferences: async ({ secretKey, secretPath }) => {
- if (failing.has(secretKey)) throw new Error(`cannot expand ${secretKey} in ${secretPath}`);
- return `ok-${secretKey}`;
- }
- });
-
- expect(errors).toEqual([
- { path: "/b", error: "cannot expand B2 in /b" },
- { path: "/c", error: "cannot expand C1 in /c" },
- { path: "/c", error: "cannot expand C2 in /c" }
- ]);
- for (const error of errors) {
- const [, key, pathInMessage] = /cannot expand (\S+) in (\S+)/.exec(error.error) ?? [];
- expect(pathInMessage).toBe(error.path);
- expect(secrets.find((s) => s.secretKey === key)?.secretPath).toBe(error.path);
- }
-
- expect(secrets.find((s) => s.secretKey === "A1")?.secretValue).toBe("ok-A1");
- expect(secrets.find((s) => s.secretKey === "B2")?.secretValue).toBe("ref-B2");
- });
-
- test("throws ClientClosedRequestError instead of reporting expansions cut short by a disconnect", async () => {
- const secrets = [makeSecret("/a", "A1"), makeSecret("/b", "B1")];
-
- await expect(
- expandSecretReferencesGroupedByPath({
- secrets,
- environment: "dev",
- expandSecretReferences: async ({ secretKey }) => {
- if (secretKey === "B1") throw new ClientClosedRequestError();
- throw new Error(`cannot expand ${secretKey}`);
- }
- })
- ).rejects.toBeInstanceOf(ClientClosedRequestError);
- });
-
- test("keeps the mapping correct across many paths", async () => {
- const pathCount = 2000;
- const secrets = Array.from({ length: pathCount }, (_, i) => makeSecret(`/p-${i}`, `K${i}`));
-
- const errors = await expandSecretReferencesGroupedByPath({
- secrets,
- environment: "dev",
- expandSecretReferences: async ({ secretKey, secretPath }) => {
- if (Number(secretKey.slice(1)) % 7 === 0) throw new Error(`fail:${secretPath}`);
- return secretKey;
- }
- });
-
- expect(errors).toHaveLength(Math.ceil(pathCount / 7));
- for (const error of errors) {
- expect(error.error).toBe(`fail:${error.path}`);
- }
+import { SecretType } from "@app/db/schemas";
+
+import { fnSecretBulkDelete } from "./secret-v2-bridge-fns";
+
+describe("fnSecretBulkDelete", () => {
+ test("removes the reminder of every deleted shared secret, whatever the legacy repeat-days column holds", async () => {
+ const removeSecretReminder = vi.fn().mockResolvedValue(undefined);
+ const tx = { tx: "bulk-delete" } as never;
+
+ await fnSecretBulkDelete({
+ folderId: "folder-1",
+ projectId: "proj-1",
+ inputSecrets: [{ type: SecretType.Shared, secretKey: "DB_PASSWORD" }],
+ actorId: "user-1",
+ tx,
+ commitChanges: [],
+ secretDAL: {
+ deleteMany: vi.fn().mockResolvedValue([
+ { id: "secret-1", type: SecretType.Shared, reminderRepeatDays: null },
+ { id: "secret-2", type: SecretType.Personal, reminderRepeatDays: null }
+ ])
+ },
+ secretQueueService: { removeSecretReminder },
+ folderCommitService: { createCommit: vi.fn() },
+ secretVersionDAL: { findLatestVersionMany: vi.fn().mockResolvedValue({}) }
+ } as never);
+
+ expect(removeSecretReminder).toHaveBeenCalledTimes(1);
+ expect(removeSecretReminder).toHaveBeenCalledWith({ secretId: "secret-1", projectId: "proj-1" }, tx);
});
});
diff --git a/backend/src/services/secret-v2-bridge/secret-v2-bridge-fns.ts b/backend/src/services/secret-v2-bridge/secret-v2-bridge-fns.ts
index b3c100e725..b25d441f06 100644
--- a/backend/src/services/secret-v2-bridge/secret-v2-bridge-fns.ts
+++ b/backend/src/services/secret-v2-bridge/secret-v2-bridge-fns.ts
@@ -449,13 +449,8 @@ export const fnSecretBulkDelete = async ({
await Promise.all(
deletedSecrets
- .filter(({ reminderRepeatDays }) => Boolean(reminderRepeatDays))
- .map(({ id, reminderRepeatDays }) =>
- secretQueueService.removeSecretReminder(
- { secretId: id, repeatDays: reminderRepeatDays as number, projectId },
- tx
- )
- )
+ .filter(({ type }) => type === SecretType.Shared)
+ .map(({ id }) => secretQueueService.removeSecretReminder({ secretId: id, projectId }, tx))
);
const secretVersions = await secretVersionDAL.findLatestVersionMany(
diff --git a/backend/src/services/secret-v2-bridge/secret-v2-bridge-types.ts b/backend/src/services/secret-v2-bridge/secret-v2-bridge-types.ts
index cb3c61ff09..0412dd5741 100644
--- a/backend/src/services/secret-v2-bridge/secret-v2-bridge-types.ts
+++ b/backend/src/services/secret-v2-bridge/secret-v2-bridge-types.ts
@@ -362,7 +362,7 @@ export type TCreateSecretReminderDTO = {
export type TRemoveSecretReminderDTO = {
secretId: string;
- repeatDays: number;
+ repeatDays?: number;
projectId: string;
};
diff --git a/backend/src/services/secret/secret-fns.ts b/backend/src/services/secret/secret-fns.ts
index 1380ae943d..033190a727 100644
--- a/backend/src/services/secret/secret-fns.ts
+++ b/backend/src/services/secret/secret-fns.ts
@@ -1,4 +1,5 @@
/* eslint-disable no-await-in-loop */
+import { Knex } from "knex";
import path from "path";
import RE2 from "re2";
@@ -36,7 +37,6 @@ import { TProjectEnvDALFactory } from "../project-env/project-env-dal";
import { TReminderServiceFactory } from "../reminder/reminder-types";
import { TSecretFolderDALFactory } from "../secret-folder/secret-folder-dal";
import { createSecretBlindIndexer } from "../secret-v2-bridge/secret-blind-index-fns";
-import { TSecretV2BridgeDALFactory } from "../secret-v2-bridge/secret-v2-bridge-dal";
import { TSecretDALFactory } from "./secret-dal";
import {
TCreateManySecretsRawFn,
@@ -1194,36 +1194,31 @@ export const decryptSecretWithBot = (
type TFnDeleteProjectSecretReminders = {
secretDAL: Pick<TSecretDALFactory, "find">;
- secretV2BridgeDAL: Pick<TSecretV2BridgeDALFactory, "find">;
- reminderService: Pick<TReminderServiceFactory, "deleteReminderBySecretId">;
+ reminderService: Pick<TReminderServiceFactory, "deleteReminderBySecretId" | "deleteRemindersByProjectId">;
projectBotService: Pick<TProjectBotServiceFactory, "getBotKey">;
folderDAL: Pick<TSecretFolderDALFactory, "findByProjectId">;
};
export const fnDeleteProjectSecretReminders = async (
projectId: string,
- { secretDAL, secretV2BridgeDAL, reminderService, projectBotService, folderDAL }: TFnDeleteProjectSecretReminders
+ { secretDAL, reminderService, projectBotService, folderDAL }: TFnDeleteProjectSecretReminders,
+ tx?: Knex
) => {
- const projectFolders = await folderDAL.findByProjectId(projectId);
const { shouldUseSecretV2Bridge } = await projectBotService.getBotKey(projectId, false);
+ if (shouldUseSecretV2Bridge) {
+ await reminderService.deleteRemindersByProjectId(projectId, tx);
+ return;
+ }
- const projectSecrets = shouldUseSecretV2Bridge
- ? await secretV2BridgeDAL.find({
- $in: { folderId: projectFolders.map((folder) => folder.id) },
- $notNull: ["reminderRepeatDays"]
- })
- : await secretDAL.find({
- $in: { folderId: projectFolders.map((folder) => folder.id) },
- $notNull: ["secretReminderRepeatDays"]
- });
+ const projectFolders = await folderDAL.findByProjectId(projectId);
+ const projectSecrets = await secretDAL.find({
+ $in: { folderId: projectFolders.map((folder) => folder.id) },
+ $notNull: ["secretReminderRepeatDays"]
+ });
for await (const secret of projectSecrets) {
- const repeatDays = shouldUseSecretV2Bridge
- ? (secret as { reminderRepeatDays: number }).reminderRepeatDays
- : (secret as { secretReminderRepeatDays: number }).secretReminderRepeatDays;
-
- if (repeatDays) {
- await reminderService.deleteReminderBySecretId(secret.id, projectId);
+ if (secret.secretReminderRepeatDays) {
+ await reminderService.deleteReminderBySecretId(secret.id, projectId, tx);
}
}
};
diff --git a/backend/src/services/secret/secret-types.ts b/backend/src/services/secret/secret-types.ts
index 1cf183a4b3..84547a42a4 100644
--- a/backend/src/services/secret/secret-types.ts
+++ b/backend/src/services/secret/secret-types.ts
@@ -456,7 +456,7 @@ export type THandleReminderDTO = {
export type TRemoveSecretReminderDTO = {
secretId: string;
- repeatDays: number;
+ repeatDays?: number;
projectId: string;
deleteRecipients?: boolean;
};