datocms-plugin-record-bin 2.0.0 → 3.0.0

package/src/utils/getRuntimeMode.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+import { getRuntimeMode } from "./getRuntimeMode";
+
+describe("getRuntimeMode", () => {
+  it("prefers explicit runtimeMode from plugin parameters", () => {
+    expect(
+      getRuntimeMode({
+        runtimeMode: "lambdaless",
+        deploymentURL: "https://record-bin.example.com",
+      })
+    ).toBe("lambdaless");
+
+    expect(
+      getRuntimeMode({
+        runtimeMode: "lambda",
+      })
+    ).toBe("lambda");
+  });
+
+  it("accepts legacy boolean lambdaFullMode parameter", () => {
+    expect(
+      getRuntimeMode({
+        lambdaFullMode: true,
+      })
+    ).toBe("lambda");
+
+    expect(
+      getRuntimeMode({
+        lambdaFullMode: false,
+        deploymentURL: "https://record-bin.example.com",
+      })
+    ).toBe("lambdaless");
+  });
+
+  it("returns lambda when deploymentURL exists", () => {
+    expect(
+      getRuntimeMode({
+        deploymentURL: "https://record-bin.example.com",
+      })
+    ).toBe("lambda");
+  });
+
+  it("returns lambda when vercelURL exists and deploymentURL is empty", () => {
+    expect(
+      getRuntimeMode({
+        deploymentURL: "   ",
+        vercelURL: "https://record-bin.example.com",
+      })
+    ).toBe("lambda");
+  });
+
+  it("returns lambdaless when no URL is configured", () => {
+    expect(getRuntimeMode(undefined)).toBe("lambdaless");
+    expect(getRuntimeMode({})).toBe("lambdaless");
+    expect(getRuntimeMode({ deploymentURL: "" })).toBe("lambdaless");
+  });
+});

package/src/utils/getRuntimeMode.ts

@@ -0,0 +1,23 @@
+import { getDeploymentUrlFromParameters } from "./getDeploymentUrlFromParameters";
+
+type PluginParameters = Record<string, unknown> | undefined;
+
+export type RuntimeMode = "lambda" | "lambdaless";
+
+const isRuntimeMode = (value: unknown): value is RuntimeMode =>
+  value === "lambda" || value === "lambdaless";
+
+export const getRuntimeMode = (parameters: PluginParameters): RuntimeMode => {
+  const configuredRuntimeMode = parameters?.runtimeMode;
+  if (isRuntimeMode(configuredRuntimeMode)) {
+    return configuredRuntimeMode;
+  }
+
+  if (typeof parameters?.lambdaFullMode === "boolean") {
+    return parameters.lambdaFullMode ? "lambda" : "lambdaless";
+  }
+
+  return getDeploymentUrlFromParameters(parameters).trim()
+    ? "lambda"
+    : "lambdaless";
+};

package/src/utils/lambdaLessCapture.test.ts

@@ -0,0 +1,218 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { buildClient, SchemaTypes } from "@datocms/cma-client-browser";
+import { captureDeletedItemsWithoutLambda } from "./lambdaLessCapture";
+
+vi.mock("@datocms/cma-client-browser", () => ({
+  buildClient: vi.fn(),
+}));
+
+type ClientMock = {
+  itemTypes: {
+    find: ReturnType<typeof vi.fn>;
+    create: ReturnType<typeof vi.fn>;
+    update: ReturnType<typeof vi.fn>;
+  };
+  fields: {
+    create: ReturnType<typeof vi.fn>;
+  };
+  items: {
+    rawFind: ReturnType<typeof vi.fn>;
+    create: ReturnType<typeof vi.fn>;
+  };
+};
+
+const createClientMock = (): ClientMock => ({
+  itemTypes: {
+    find: vi.fn(),
+    create: vi.fn(),
+    update: vi.fn(),
+  },
+  fields: {
+    create: vi.fn(),
+  },
+  items: {
+    rawFind: vi.fn(),
+    create: vi.fn(),
+  },
+});
+
+const createHookItem = (
+  id: string,
+  modelId: string
+): SchemaTypes.Item =>
+  ({
+    type: "item",
+    id,
+    relationships: {
+      item_type: {
+        data: {
+          type: "item_type",
+          id: modelId,
+        },
+      },
+    },
+    attributes: {},
+    meta: {} as SchemaTypes.Item["meta"],
+  } as SchemaTypes.Item);
+
+const createCtxMock = (
+  token?: string
+): {
+  currentUserAccessToken: string | undefined;
+  environment: string;
+  plugin: { attributes: { parameters: Record<string, unknown> } };
+  notice: ReturnType<typeof vi.fn>;
+} => ({
+  currentUserAccessToken: token,
+  environment: "main",
+  plugin: {
+    attributes: {
+      parameters: {},
+    },
+  },
+  notice: vi.fn(),
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.clearAllMocks();
+});
+
+describe("captureDeletedItemsWithoutLambda", () => {
+  it("captures deleted records using nested rawFind payload", async () => {
+    const clientMock = createClientMock();
+    clientMock.itemTypes.find.mockResolvedValue({ id: "record-bin-model-id" });
+    clientMock.items.rawFind.mockResolvedValue({
+      data: {
+        type: "item",
+        id: "item-1",
+        relationships: {
+          item_type: {
+            data: {
+              type: "item_type",
+              id: "blog-model-id",
+            },
+          },
+        },
+        attributes: {
+          title: "Post title",
+        },
+        meta: {},
+      },
+    });
+    clientMock.items.create.mockResolvedValue({ id: "trash-1" });
+
+    vi.mocked(buildClient).mockReturnValue(
+      clientMock as unknown as ReturnType<typeof buildClient>
+    );
+
+    const ctx = createCtxMock("token");
+
+    const result = await captureDeletedItemsWithoutLambda(
+      [createHookItem("item-1", "blog-model-id")],
+      ctx as never
+    );
+
+    expect(result).toEqual({
+      capturedCount: 1,
+      failedItemIds: [],
+      skippedRecordBinItems: 0,
+    });
+    expect(clientMock.items.rawFind).toHaveBeenCalledWith("item-1", {
+      nested: true,
+    });
+    expect(clientMock.items.create).toHaveBeenCalledTimes(1);
+    const requestPayload = clientMock.items.create.mock.calls[0][0];
+    expect(requestPayload.model).toBe("blog-model-id");
+    expect(requestPayload.record_body).toEqual(expect.any(String));
+    expect(JSON.parse(requestPayload.record_body).event_type).toBe(
+      "to_be_restored"
+    );
+  });
+
+  it("skips records belonging to record_bin model", async () => {
+    const clientMock = createClientMock();
+    clientMock.itemTypes.find.mockResolvedValue({ id: "record-bin-model-id" });
+
+    vi.mocked(buildClient).mockReturnValue(
+      clientMock as unknown as ReturnType<typeof buildClient>
+    );
+
+    const ctx = createCtxMock("token");
+
+    const result = await captureDeletedItemsWithoutLambda(
+      [createHookItem("trash-item", "record-bin-model-id")],
+      ctx as never
+    );
+
+    expect(result).toEqual({
+      capturedCount: 0,
+      failedItemIds: [],
+      skippedRecordBinItems: 1,
+    });
+    expect(clientMock.items.rawFind).not.toHaveBeenCalled();
+    expect(clientMock.items.create).not.toHaveBeenCalled();
+  });
+
+  it("aggregates failures and keeps deletion fail-open", async () => {
+    const clientMock = createClientMock();
+    clientMock.itemTypes.find.mockResolvedValue({ id: "record-bin-model-id" });
+    clientMock.items.rawFind
+      .mockRejectedValueOnce(new Error("fetch failed"))
+      .mockResolvedValueOnce({
+        data: {
+          type: "item",
+          id: "item-2",
+          relationships: {
+            item_type: {
+              data: {
+                type: "item_type",
+                id: "page-model-id",
+              },
+            },
+          },
+          attributes: {
+            title: "Page title",
+          },
+          meta: {},
+        },
+      });
+    clientMock.items.create.mockResolvedValue({ id: "trash-2" });
+
+    vi.mocked(buildClient).mockReturnValue(
+      clientMock as unknown as ReturnType<typeof buildClient>
+    );
+
+    const ctx = createCtxMock("token");
+
+    const result = await captureDeletedItemsWithoutLambda(
+      [
+        createHookItem("item-1", "post-model-id"),
+        createHookItem("item-2", "page-model-id"),
+      ],
+      ctx as never
+    );
+
+    expect(result.capturedCount).toBe(1);
+    expect(result.failedItemIds).toEqual(["item-1"]);
+    expect(ctx.notice).toHaveBeenCalledWith(
+      "Record Bin could not archive 1 deleted record(s). Deletion still completed."
+    );
+  });
+
+  it("warns and returns when access token is missing", async () => {
+    const ctx = createCtxMock();
+
+    const result = await captureDeletedItemsWithoutLambda(
+      [createHookItem("item-1", "blog-model-id")],
+      ctx as never
+    );
+
+    expect(result.capturedCount).toBe(0);
+    expect(result.failedItemIds).toEqual(["item-1"]);
+    expect(ctx.notice).toHaveBeenCalledWith(
+      "Record Bin could not archive deleted records because currentUserAccessToken is missing."
+    );
+    expect(buildClient).not.toHaveBeenCalled();
+  });
+});

package/src/utils/lambdaLessCapture.ts

@@ -0,0 +1,160 @@
+import { buildClient, SchemaTypes } from "@datocms/cma-client-browser";
+import { OnBeforeItemsDestroyCtx } from "datocms-plugin-sdk";
+import { createDebugLogger, isDebugEnabled } from "./debugLogger";
+import { ensureRecordBinModel } from "./recordBinModel";
+import {
+  buildRecordBinCompatiblePayload,
+  extractEntityAttributes,
+  extractEntityModelId,
+} from "./recordBinPayload";
+
+const buildTrashLabel = (
+  attributes: Record<string, unknown>,
+  modelID: string
+): string => {
+  let titleValue = "No title record";
+  for (const attributeKey of Object.keys(attributes)) {
+    const attributeValue = attributes[attributeKey];
+    if (
+      typeof attributeValue === "string" &&
+      Number.isNaN(Number(attributeValue))
+    ) {
+      titleValue = attributeValue;
+      break;
+    }
+  }
+
+  return `${titleValue} | Model: ${modelID} | ${new Date().toDateString()}`;
+};
+
+const getHookItemModelId = (item: SchemaTypes.Item): string | undefined => {
+  const candidateModelId = item.relationships?.item_type?.data?.id;
+  return typeof candidateModelId === "string" ? candidateModelId : undefined;
+};
+
+export type LambdaLessCaptureResult = {
+  capturedCount: number;
+  failedItemIds: string[];
+  skippedRecordBinItems: number;
+};
+
+export const captureDeletedItemsWithoutLambda = async (
+  items: SchemaTypes.Item[],
+  ctx: OnBeforeItemsDestroyCtx
+): Promise<LambdaLessCaptureResult> => {
+  const debugLogger = createDebugLogger(
+    isDebugEnabled(ctx.plugin.attributes.parameters),
+    "lambdaLessCapture"
+  );
+
+  const result: LambdaLessCaptureResult = {
+    capturedCount: 0,
+    failedItemIds: [],
+    skippedRecordBinItems: 0,
+  };
+
+  if (!ctx.currentUserAccessToken) {
+    debugLogger.warn(
+      "Skipping Lambda-less capture because currentUserAccessToken is missing"
+    );
+    await ctx.notice(
+      "Record Bin could not archive deleted records because currentUserAccessToken is missing."
+    );
+    return {
+      ...result,
+      failedItemIds: items
+        .map((item) => item.id)
+        .filter((itemId): itemId is string => Boolean(itemId)),
+    };
+  }
+
+  const client = buildClient({
+    apiToken: ctx.currentUserAccessToken,
+    environment: ctx.environment,
+  });
+
+  let recordBinModelId = "";
+  try {
+    const recordBinModel = await ensureRecordBinModel(client);
+    recordBinModelId = recordBinModel.id;
+  } catch (error) {
+    debugLogger.error("Could not ensure record_bin model before delete capture", error);
+    await ctx.notice(
+      "Record Bin could not archive deleted records because the record_bin model is unavailable."
+    );
+    return {
+      ...result,
+      failedItemIds: items
+        .map((item) => item.id)
+        .filter((itemId): itemId is string => Boolean(itemId)),
+    };
+  }
+
+  for (const item of items) {
+    const itemId = item.id;
+    if (!itemId) {
+      continue;
+    }
+
+    if (getHookItemModelId(item) === recordBinModelId) {
+      result.skippedRecordBinItems += 1;
+      continue;
+    }
+
+    try {
+      const fullItemResponse = await client.items.rawFind(itemId, { nested: true });
+      const fullItemEntity = fullItemResponse.data as unknown as Record<
+        string,
+        unknown
+      >;
+      const deletedModelID =
+        extractEntityModelId(fullItemEntity) ?? getHookItemModelId(item);
+      if (!deletedModelID) {
+        throw new Error("Deleted record model id could not be determined.");
+      }
+
+      if (deletedModelID === recordBinModelId) {
+        result.skippedRecordBinItems += 1;
+        continue;
+      }
+
+      const trashLabel = buildTrashLabel(
+        extractEntityAttributes(fullItemEntity),
+        deletedModelID
+      );
+
+      const payload = buildRecordBinCompatiblePayload({
+        environment: ctx.environment,
+        entity: fullItemEntity,
+      });
+
+      await client.items.create({
+        item_type: {
+          type: "item_type",
+          id: recordBinModelId,
+        },
+        label: trashLabel,
+        model: deletedModelID,
+        record_body: JSON.stringify(payload),
+        date_of_deletion: new Date().toISOString(),
+      });
+
+      result.capturedCount += 1;
+    } catch (error) {
+      result.failedItemIds.push(itemId);
+      debugLogger.warn("Could not archive deleted record", {
+        itemId,
+        error,
+      });
+    }
+  }
+
+  if (result.failedItemIds.length > 0) {
+    await ctx.notice(
+      `Record Bin could not archive ${result.failedItemIds.length} deleted record(s). Deletion still completed.`
+    );
+  }
+
+  debugLogger.log("Lambda-less delete capture finished", result);
+  return result;
+};

package/src/utils/lambdaLessCleanup.test.ts

@@ -0,0 +1,125 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { buildClient } from "@datocms/cma-client-browser";
+import { cleanupRecordBinWithoutLambda } from "./lambdaLessCleanup";
+
+vi.mock("@datocms/cma-client-browser", () => ({
+  buildClient: vi.fn(),
+}));
+
+type ClientMock = {
+  itemTypes: {
+    find: ReturnType<typeof vi.fn>;
+  };
+  items: {
+    list: ReturnType<typeof vi.fn>;
+    bulkDestroy: ReturnType<typeof vi.fn>;
+  };
+};
+
+const createClientMock = (): ClientMock => ({
+  itemTypes: {
+    find: vi.fn(),
+  },
+  items: {
+    list: vi.fn(),
+    bulkDestroy: vi.fn(),
+  },
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.clearAllMocks();
+});
+
+describe("cleanupRecordBinWithoutLambda", () => {
+  it("deletes aged records from record_bin model", async () => {
+    const clientMock = createClientMock();
+    clientMock.itemTypes.find.mockResolvedValue({ id: "record-bin-model-id" });
+    clientMock.items.list.mockResolvedValue([
+      { id: "trash-1" },
+      { id: "trash-2" },
+    ]);
+    clientMock.items.bulkDestroy.mockResolvedValue({});
+
+    vi.mocked(buildClient).mockReturnValue(
+      clientMock as unknown as ReturnType<typeof buildClient>
+    );
+
+    const result = await cleanupRecordBinWithoutLambda({
+      currentUserAccessToken: "token",
+      environment: "main",
+      numberOfDays: 30,
+    });
+
+    expect(result).toEqual({
+      deletedCount: 2,
+      skipped: false,
+    });
+    expect(clientMock.items.list).toHaveBeenCalledWith({
+      filter: {
+        fields: {
+          dateOfDeletion: {
+            lte: expect.any(String),
+          },
+        },
+        type: "record_bin",
+      },
+    });
+    expect(clientMock.items.bulkDestroy).toHaveBeenCalledWith({
+      items: [
+        {
+          type: "item",
+          id: "trash-1",
+        },
+        {
+          type: "item",
+          id: "trash-2",
+        },
+      ],
+    });
+  });
+
+  it("returns early when record_bin model does not exist", async () => {
+    const clientMock = createClientMock();
+    clientMock.itemTypes.find.mockRejectedValue(new Error("Not found"));
+
+    vi.mocked(buildClient).mockReturnValue(
+      clientMock as unknown as ReturnType<typeof buildClient>
+    );
+
+    const result = await cleanupRecordBinWithoutLambda({
+      currentUserAccessToken: "token",
+      environment: "main",
+      numberOfDays: 30,
+    });
+
+    expect(result).toEqual({
+      deletedCount: 0,
+      skipped: true,
+    });
+    expect(clientMock.items.list).not.toHaveBeenCalled();
+    expect(clientMock.items.bulkDestroy).not.toHaveBeenCalled();
+  });
+
+  it("handles empty cleanup sets", async () => {
+    const clientMock = createClientMock();
+    clientMock.itemTypes.find.mockResolvedValue({ id: "record-bin-model-id" });
+    clientMock.items.list.mockResolvedValue([]);
+
+    vi.mocked(buildClient).mockReturnValue(
+      clientMock as unknown as ReturnType<typeof buildClient>
+    );
+
+    const result = await cleanupRecordBinWithoutLambda({
+      currentUserAccessToken: "token",
+      environment: "main",
+      numberOfDays: 30,
+    });
+
+    expect(result).toEqual({
+      deletedCount: 0,
+      skipped: false,
+    });
+    expect(clientMock.items.bulkDestroy).not.toHaveBeenCalled();
+  });
+});

package/src/utils/lambdaLessCleanup.ts

@@ -0,0 +1,69 @@
+import { buildClient } from "@datocms/cma-client-browser";
+
+export type CleanupRecordBinWithoutLambdaInput = {
+  currentUserAccessToken: string | undefined;
+  environment: string;
+  numberOfDays: number;
+};
+
+export type CleanupRecordBinWithoutLambdaResult = {
+  deletedCount: number;
+  skipped: boolean;
+};
+
+export const cleanupRecordBinWithoutLambda = async ({
+  currentUserAccessToken,
+  environment,
+  numberOfDays,
+}: CleanupRecordBinWithoutLambdaInput): Promise<CleanupRecordBinWithoutLambdaResult> => {
+  if (!currentUserAccessToken) {
+    throw new Error("Missing currentUserAccessToken for Lambda-less cleanup.");
+  }
+
+  const client = buildClient({
+    apiToken: currentUserAccessToken,
+    environment,
+  });
+
+  try {
+    await client.itemTypes.find("record_bin");
+  } catch {
+    return {
+      deletedCount: 0,
+      skipped: true,
+    };
+  }
+
+  const cutOffDate = new Date();
+  cutOffDate.setDate(new Date().getDate() - numberOfDays);
+
+  const recordsToDelete = await client.items.list({
+    filter: {
+      fields: {
+        dateOfDeletion: {
+          lte: cutOffDate.toISOString(),
+        },
+      },
+      type: "record_bin",
+    },
+  });
+
+  if (recordsToDelete.length === 0) {
+    return {
+      deletedCount: 0,
+      skipped: false,
+    };
+  }
+
+  await client.items.bulkDestroy({
+    items: recordsToDelete.map((item) => ({
+      type: "item",
+      id: item.id,
+    })),
+  });
+
+  return {
+    deletedCount: recordsToDelete.length,
+    skipped: false,
+  };
+};