datocms-plugin-record-bin 1.9.0 → 3.0.0

package/src/utils/lambdaLessRestore.test.ts

@@ -0,0 +1,248 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { buildClient } from "@datocms/cma-client-browser";
+import {
+  isLambdaLessRestoreError,
+  restoreRecordWithoutLambda,
+} from "./lambdaLessRestore";
+
+vi.mock("@datocms/cma-client-browser", () => ({
+  buildClient: vi.fn(),
+}));
+
+type ClientMock = {
+  items: {
+    rawCreate: ReturnType<typeof vi.fn>;
+    destroy: ReturnType<typeof vi.fn>;
+  };
+};
+
+const createClientMock = (): ClientMock => ({
+  items: {
+    rawCreate: vi.fn(),
+    destroy: vi.fn(),
+  },
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.clearAllMocks();
+});
+
+describe("restoreRecordWithoutLambda", () => {
+  it("restores a record, sanitizes payload and removes trash item", async () => {
+    const clientMock = createClientMock();
+    clientMock.items.rawCreate.mockResolvedValue({
+      data: {
+        id: "restored-item-id",
+        relationships: {
+          item_type: {
+            data: {
+              id: "restored-model-id",
+            },
+          },
+        },
+      },
+    });
+    clientMock.items.destroy.mockResolvedValue({});
+
+    vi.mocked(buildClient).mockReturnValue(
+      clientMock as unknown as ReturnType<typeof buildClient>
+    );
+
+    const recordBody = {
+      event_type: "to_be_restored",
+      environment: "main",
+      entity: {
+        type: "item",
+        id: "deleted-item-id",
+        attributes: {
+          title: "Old title",
+          created_at: "2024-01-01T00:00:00.000Z",
+          updated_at: "2024-01-02T00:00:00.000Z",
+          content: [
+            {
+              id: "block-id",
+              type: "item",
+              attributes: {
+                text: "Nested block",
+              },
+              relationships: {
+                item_type: {
+                  data: {
+                    type: "item_type",
+                    id: "block-model-id",
+                  },
+                },
+              },
+            },
+          ],
+        },
+        relationships: {
+          item_type: {
+            data: {
+              type: "item_type",
+              id: "article-model-id",
+            },
+          },
+          creator: {
+            data: {
+              type: "user",
+              id: "user-id",
+            },
+          },
+        },
+        meta: {
+          created_at: "2024-01-01T00:00:00.000Z",
+          first_published_at: null,
+          status: "published",
+        },
+      },
+    };
+
+    const result = await restoreRecordWithoutLambda({
+      currentUserAccessToken: "token",
+      fallbackEnvironment: "main",
+      recordBody,
+      trashRecordID: "trash-id",
+    });
+
+    expect(result).toEqual({
+      restoredRecord: {
+        id: "restored-item-id",
+        modelID: "restored-model-id",
+      },
+    });
+
+    const createPayload = clientMock.items.rawCreate.mock.calls[0][0];
+    expect(createPayload.data.id).toBeUndefined();
+    expect(createPayload.data.attributes.created_at).toBeUndefined();
+    expect(createPayload.data.attributes.updated_at).toBeUndefined();
+    expect(createPayload.data.relationships.creator).toBeUndefined();
+    expect(createPayload.data.meta).toEqual({
+      created_at: "2024-01-01T00:00:00.000Z",
+      first_published_at: null,
+    });
+    expect(createPayload.data.attributes.content[0].id).toBeUndefined();
+    expect(
+      createPayload.data.attributes.content[0].relationships.item_type.data.id
+    ).toBe("block-model-id");
+    expect(clientMock.items.destroy).toHaveBeenCalledWith("trash-id");
+  });
+
+  it("supports raw entity payloads without webhook envelope", async () => {
+    const clientMock = createClientMock();
+    clientMock.items.rawCreate.mockResolvedValue({
+      data: {
+        id: "restored-item-id",
+        relationships: {
+          item_type: {
+            data: {
+              id: "restored-model-id",
+            },
+          },
+        },
+      },
+    });
+    clientMock.items.destroy.mockResolvedValue({});
+
+    vi.mocked(buildClient).mockReturnValue(
+      clientMock as unknown as ReturnType<typeof buildClient>
+    );
+
+    await restoreRecordWithoutLambda({
+      currentUserAccessToken: "token",
+      fallbackEnvironment: "fallback-env",
+      recordBody: {
+        type: "item",
+        id: "item-id",
+        attributes: {
+          title: "Standalone payload",
+        },
+        relationships: {
+          item_type: {
+            data: {
+              type: "item_type",
+              id: "model-id",
+            },
+          },
+        },
+        meta: {
+          created_at: "2024-01-01T00:00:00.000Z",
+          first_published_at: null,
+        },
+      },
+      trashRecordID: "trash-id",
+    });
+
+    expect(buildClient).toHaveBeenCalledWith({
+      apiToken: "token",
+      environment: "fallback-env",
+    });
+  });
+
+  it("throws LambdaLessRestoreError with lambda-like payload on rawCreate errors", async () => {
+    const clientMock = createClientMock();
+    clientMock.items.rawCreate.mockRejectedValue({
+      errors: [
+        {
+          attributes: {
+            code: "VALIDATION_INVALID",
+            details: {
+              code: "INVALID_FIELD",
+              field: "title",
+            },
+          },
+        },
+      ],
+    });
+
+    vi.mocked(buildClient).mockReturnValue(
+      clientMock as unknown as ReturnType<typeof buildClient>
+    );
+
+    await expect(
+      restoreRecordWithoutLambda({
+        currentUserAccessToken: "token",
+        fallbackEnvironment: "main",
+        recordBody: {
+          event_type: "to_be_restored",
+          environment: "main",
+          entity: {
+            type: "item",
+            id: "item-id",
+            attributes: {
+              title: "Broken payload",
+            },
+            relationships: {
+              item_type: {
+                data: {
+                  type: "item_type",
+                  id: "model-id",
+                },
+              },
+            },
+            meta: {
+              created_at: "2024-01-01T00:00:00.000Z",
+              first_published_at: null,
+            },
+          },
+        },
+        trashRecordID: "trash-id",
+      })
+    ).rejects.toSatisfy((error: unknown) => {
+      if (!isLambdaLessRestoreError(error)) {
+        return false;
+      }
+
+      expect(error.restorationError.simplifiedError.code).toBe(
+        "VALIDATION_INVALID"
+      );
+      expect(error.restorationError.fullErrorPayload).toContain(
+        "VALIDATION_INVALID"
+      );
+      return true;
+    });
+
+    expect(clientMock.items.destroy).not.toHaveBeenCalled();
+  });
+});

package/src/utils/lambdaLessRestore.ts

@@ -0,0 +1,159 @@
+import { buildClient } from "@datocms/cma-client-browser";
+import { errorObject } from "../types/types";
+import { normalizeRecordBinPayload } from "./recordBinPayload";
+import { buildRestoreErrorPayload } from "./restoreError";
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  Boolean(value) && typeof value === "object" && !Array.isArray(value);
+
+const recursivelyDeleteAllBlockIDs = (
+  recursiveObject: unknown,
+  previousKey: string
+) => {
+  if (Array.isArray(recursiveObject)) {
+    for (const arrayItem of recursiveObject) {
+      recursivelyDeleteAllBlockIDs(arrayItem, previousKey);
+    }
+    return;
+  }
+
+  if (!isRecord(recursiveObject)) {
+    return;
+  }
+
+  if (
+    Object.prototype.hasOwnProperty.call(recursiveObject, "id") &&
+    previousKey !== "data"
+  ) {
+    delete recursiveObject.id;
+  }
+
+  for (const key of Object.keys(recursiveObject)) {
+    const child = recursiveObject[key];
+    if (typeof child === "object" && child !== null) {
+      recursivelyDeleteAllBlockIDs(child, key);
+    }
+  }
+};
+
+const deepCloneRecord = (
+  value: Record<string, unknown>
+): Record<string, unknown> => JSON.parse(JSON.stringify(value)) as Record<string, unknown>;
+
+const sanitizeEntityForCreation = (
+  entity: Record<string, unknown>
+): Record<string, unknown> => {
+  const requestBody = deepCloneRecord(entity);
+  delete requestBody.id;
+
+  const attributes = isRecord(requestBody.attributes)
+    ? requestBody.attributes
+    : {};
+  delete attributes.created_at;
+  delete attributes.updated_at;
+  requestBody.attributes = attributes;
+
+  const relationships = isRecord(requestBody.relationships)
+    ? requestBody.relationships
+    : {};
+  delete relationships.creator;
+  requestBody.relationships = relationships;
+
+  const meta = isRecord(requestBody.meta) ? requestBody.meta : {};
+  requestBody.meta = {
+    created_at: meta.created_at,
+    first_published_at: meta.first_published_at,
+  };
+
+  recursivelyDeleteAllBlockIDs(requestBody, "");
+  return requestBody;
+};
+
+export class LambdaLessRestoreError extends Error {
+  readonly restorationError: errorObject;
+
+  constructor(message: string, restorationError: errorObject) {
+    super(message);
+    this.name = "LambdaLessRestoreError";
+    this.restorationError = restorationError;
+  }
+}
+
+export const isLambdaLessRestoreError = (
+  error: unknown
+): error is LambdaLessRestoreError => error instanceof LambdaLessRestoreError;
+
+export type RestoreRecordWithoutLambdaInput = {
+  currentUserAccessToken: string | undefined;
+  fallbackEnvironment: string;
+  recordBody: unknown;
+  trashRecordID: string;
+};
+
+export type RestoreRecordWithoutLambdaResult = {
+  restoredRecord: {
+    id: string;
+    modelID: string;
+  };
+};
+
+export const restoreRecordWithoutLambda = async ({
+  currentUserAccessToken,
+  fallbackEnvironment,
+  recordBody,
+  trashRecordID,
+}: RestoreRecordWithoutLambdaInput): Promise<RestoreRecordWithoutLambdaResult> => {
+  if (!currentUserAccessToken) {
+    throw new Error("Missing currentUserAccessToken for Lambda-less restore.");
+  }
+
+  const normalizedPayload = normalizeRecordBinPayload(
+    recordBody,
+    fallbackEnvironment
+  );
+  const requestBody = sanitizeEntityForCreation(normalizedPayload.entity);
+
+  const client = buildClient({
+    apiToken: currentUserAccessToken,
+    environment: normalizedPayload.environment,
+  });
+
+  let restoredRecordResponse:
+    | {
+        data: {
+          id: string;
+          relationships: {
+            item_type: {
+              data: {
+                id: string;
+              };
+            };
+          };
+        };
+      }
+    | undefined;
+
+  try {
+    restoredRecordResponse = await client.items.rawCreate({
+      data: requestBody as never,
+    });
+  } catch (error) {
+    throw new LambdaLessRestoreError(
+      "The record could not be restored!",
+      buildRestoreErrorPayload(error)
+    );
+  }
+
+  await client.items.destroy(trashRecordID);
+
+  const restoredRecordId = restoredRecordResponse.data.id;
+  const restoredModelId =
+    restoredRecordResponse.data.relationships.item_type.data.id;
+
+  return {
+    restoredRecord: {
+      id: restoredRecordId,
+      modelID: restoredModelId,
+    },
+  };
+};

package/src/utils/recordBinModel.ts

@@ -0,0 +1,108 @@
+import { buildClient } from "@datocms/cma-client-browser";
+
+type CmaClient = ReturnType<typeof buildClient>;
+
+type RecordBinModel = {
+  id: string;
+};
+
+const extractModelId = (value: unknown): string | undefined => {
+  if (!value || typeof value !== "object") {
+    return undefined;
+  }
+
+  const candidate = value as Record<string, unknown>;
+  return typeof candidate.id === "string" ? candidate.id : undefined;
+};
+
+const findExistingRecordBinModel = async (
+  client: CmaClient
+): Promise<RecordBinModel | undefined> => {
+  try {
+    const existingModel = await client.itemTypes.find("record_bin");
+    const existingModelId = extractModelId(existingModel);
+    if (!existingModelId) {
+      return undefined;
+    }
+
+    return { id: existingModelId };
+  } catch {
+    return undefined;
+  }
+};
+
+export const ensureRecordBinModel = async (
+  client: CmaClient
+): Promise<RecordBinModel> => {
+  const existingModel = await findExistingRecordBinModel(client);
+  if (existingModel) {
+    return existingModel;
+  }
+
+  let createdModelId: string | undefined;
+
+  try {
+    const createdModel = await client.itemTypes.create({
+      name: "🗑 Record Bin",
+      api_key: "record_bin",
+      collection_appearance: "table",
+    });
+    createdModelId = extractModelId(createdModel);
+  } catch (error) {
+    const modelCreatedInParallel = await findExistingRecordBinModel(client);
+    if (modelCreatedInParallel) {
+      return modelCreatedInParallel;
+    }
+
+    throw error;
+  }
+
+  if (!createdModelId) {
+    throw new Error("Record Bin model creation returned an invalid model id.");
+  }
+
+  const labelField = await client.fields.create(createdModelId, {
+    label: "Label",
+    field_type: "string",
+    api_key: "label",
+    position: 1,
+  });
+
+  await client.fields.create(createdModelId, {
+    label: "Model",
+    field_type: "string",
+    api_key: "model",
+    position: 2,
+  });
+
+  await client.fields.create(createdModelId, {
+    label: "Date of deletion",
+    field_type: "date_time",
+    api_key: "date_of_deletion",
+    position: 3,
+  });
+
+  await client.fields.create(createdModelId, {
+    label: "Record body",
+    field_type: "json",
+    api_key: "record_body",
+    position: 4,
+  });
+
+  const labelFieldId = extractModelId(labelField);
+  if (!labelFieldId) {
+    throw new Error("Record Bin label field creation returned an invalid field id.");
+  }
+
+  await client.itemTypes.update(createdModelId, {
+    title_field: {
+      type: "field",
+      id: labelFieldId,
+    },
+    collection_appearance: "table",
+  });
+
+  return {
+    id: createdModelId,
+  };
+};

package/src/utils/recordBinPayload.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildRecordBinCompatiblePayload,
+  extractEntityModelId,
+  normalizeRecordBinPayload,
+} from "./recordBinPayload";
+
+const entityFixture = {
+  type: "item",
+  id: "item-1",
+  relationships: {
+    item_type: {
+      data: {
+        type: "item_type",
+        id: "model-1",
+      },
+    },
+  },
+  attributes: {
+    title: "Hello world",
+  },
+  meta: {
+    created_at: "2024-01-01T00:00:00.000Z",
+    first_published_at: null,
+  },
+};
+
+describe("buildRecordBinCompatiblePayload", () => {
+  it("builds a webhook-compatible envelope", () => {
+    const payload = buildRecordBinCompatiblePayload({
+      environment: "main",
+      entity: entityFixture,
+      capturedAt: "2026-02-25T00:00:00.000Z",
+    });
+
+    expect(payload).toEqual({
+      event_type: "to_be_restored",
+      entity_type: "item",
+      environment: "main",
+      entity: entityFixture,
+      event_triggered_at: "2026-02-25T00:00:00.000Z",
+      related_entities: [],
+      __record_bin: {
+        source: "onBeforeItemsDestroy",
+        version: "2026-02-25",
+      },
+    });
+  });
+});
+
+describe("normalizeRecordBinPayload", () => {
+  it("normalizes synthetic payload envelopes", () => {
+    const normalized = normalizeRecordBinPayload(
+      buildRecordBinCompatiblePayload({
+        environment: "sandbox",
+        entity: entityFixture,
+      }),
+      "main"
+    );
+
+    expect(normalized.environment).toBe("sandbox");
+    expect(normalized.entity).toEqual(entityFixture);
+    expect(normalized.eventType).toBe("to_be_restored");
+  });
+
+  it("normalizes legacy webhook payload envelopes", () => {
+    const normalized = normalizeRecordBinPayload(
+      {
+        event_type: "delete",
+        environment: "staging",
+        entity: entityFixture,
+      },
+      "main"
+    );
+
+    expect(normalized.environment).toBe("staging");
+    expect(normalized.entity).toEqual(entityFixture);
+    expect(normalized.eventType).toBe("delete");
+  });
+
+  it("accepts raw entity payloads and applies fallback environment", () => {
+    const normalized = normalizeRecordBinPayload(entityFixture, "main");
+
+    expect(normalized.environment).toBe("main");
+    expect(normalized.entity).toEqual(entityFixture);
+    expect(normalized.eventType).toBeUndefined();
+  });
+
+  it("throws for malformed payloads", () => {
+    expect(() => normalizeRecordBinPayload("not-json", "main")).toThrow(
+      /Unexpected token/
+    );
+    expect(() => normalizeRecordBinPayload({ foo: "bar" }, "main")).toThrow(
+      /entity payload/
+    );
+  });
+});
+
+describe("extractEntityModelId", () => {
+  it("extracts the model id from raw entities", () => {
+    expect(extractEntityModelId(entityFixture)).toBe("model-1");
+  });
+});