datocms-plugin-record-bin 2.0.0 → 3.0.1

package/src/entrypoints/ErrorModal.tsx

@@ -1,22 +1,106 @@
 import { RenderModalCtx } from "datocms-plugin-sdk";
 import { Button, Canvas } from "datocms-react-ui";
+import { createDebugLogger, isDebugEnabled } from "../utils/debugLogger";
 
 type PropTypes = {
   ctx: RenderModalCtx;
 };
 
 const ErrorModal = ({ ctx }: PropTypes) => {
+  const debugLogger = createDebugLogger(
+    isDebugEnabled(ctx.plugin.attributes.parameters),
+    "ErrorModal"
+  );
+
+  const copyTextToClipboard = async (text: string) => {
+    if (
+      typeof navigator !== "undefined" &&
+      navigator.clipboard &&
+      typeof navigator.clipboard.writeText === "function"
+    ) {
+      await navigator.clipboard.writeText(text);
+      return;
+    }
+
+    if (typeof document === "undefined") {
+      throw new Error("Clipboard API is unavailable in this environment.");
+    }
+
+    const textArea = document.createElement("textarea");
+    textArea.value = text;
+    textArea.setAttribute("readonly", "");
+    textArea.style.position = "fixed";
+    textArea.style.left = "-9999px";
+    document.body.appendChild(textArea);
+    textArea.select();
+
+    const didCopy = document.execCommand("copy");
+    document.body.removeChild(textArea);
+
+    if (!didCopy) {
+      throw new Error("execCommand copy failed.");
+    }
+  };
+
   const handleCancelationButtonClick = () => {
+    debugLogger.log("Closing restoration error modal");
     ctx.resolve("done");
   };
 
-  const newString = (ctx.parameters.errorPayload as string)
+  const errorPayloadText = (ctx.parameters.errorPayload as string)
     .replaceAll("\\n", "\n")
     .replaceAll("\\", "");
 
+  const handleCopyButtonClick = async () => {
+    try {
+      await copyTextToClipboard(errorPayloadText);
+      debugLogger.log("Copied restoration error payload to clipboard", {
+        payloadLength: errorPayloadText.length,
+      });
+      await ctx.notice("Restoration error copied to clipboard.");
+    } catch (error) {
+      debugLogger.warn("Failed to copy restoration error payload", error);
+      await ctx.alert("Could not copy restoration error to clipboard.");
+    }
+  };
+
+  debugLogger.log("Rendering error payload in modal", {
+    payloadLength: errorPayloadText.length,
+  });
+
   return (
     <Canvas ctx={ctx}>
-      <pre>{newString}</pre>
+      <Button onClick={handleCopyButtonClick} fullWidth buttonType="muted">
+        Copy error to clipboard
+      </Button>
+      <div
+        style={{
+          marginTop: "var(--spacing-s)",
+          marginBottom: "var(--spacing-s)",
+          border: "1px solid var(--border-color)",
+          borderRadius: "6px",
+          background: "#f8f9fb",
+        }}
+      >
+        <pre
+          style={{
+            margin: 0,
+            padding: "var(--spacing-m)",
+            maxHeight: "320px",
+            overflowY: "auto",
+            overflowX: "auto",
+            whiteSpace: "pre-wrap",
+            overflowWrap: "anywhere",
+            wordBreak: "break-word",
+            fontSize: "12px",
+            lineHeight: "1.5",
+            fontFamily:
+              'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace',
+          }}
+        >
+          <code>{errorPayloadText}</code>
+        </pre>
+      </div>
       <Button
         onClick={handleCancelationButtonClick}
         fullWidth

package/src/index.tsx

@@ -1,6 +1,6 @@
 import {
   connect,
-  IntentCtx,
+  ItemFormOutletsCtx,
   ItemType,
   RenderItemFormOutletCtx,
   RenderModalCtx,
@@ -9,37 +9,64 @@ import { render } from "./utils/render";
 import ConfigScreen from "./entrypoints/ConfigScreen";
 import "datocms-react-ui/styles.css";
 import BinOutlet from "./entrypoints/BinOutlet";
-import InstallationModal from "./entrypoints/InstallationModal";
-import PreInstallConfig from "./entrypoints/PreInstallConfig";
 import ErrorModal from "./entrypoints/ErrorModal";
 import binCleanup from "./utils/binCleanup";
+import { createDebugLogger, isDebugEnabled } from "./utils/debugLogger";
+import { getRuntimeMode } from "./utils/getRuntimeMode";
+import { captureDeletedItemsWithoutLambda } from "./utils/lambdaLessCapture";
 
 connect({
   async onBoot(ctx) {
-    if (
-      !ctx.plugin.attributes.parameters.installationState &&
-      !ctx.plugin.attributes.parameters.hasBeenPrompted
-    ) {
-      ctx.updatePluginParameters({ hasBeenPrompted: true });
-      await ctx.openModal({
-        id: "installationModal",
-        title: "Record Bin setup",
-        width: "m",
-        parameters: { foo: "bar" },
-        closeDisabled: true,
-      });
-      return;
-    }
+    const pluginParameters = ctx.plugin.attributes.parameters;
+    const debugLogger = createDebugLogger(
+      isDebugEnabled(pluginParameters),
+      "index.onBoot"
+    );
+    debugLogger.log("Plugin boot started");
+
+    debugLogger.log("Running daily cleanup check");
     await binCleanup(ctx);
+    debugLogger.log("Plugin boot completed");
   },
-  renderConfigScreen(ctx) {
-    if (ctx.plugin.attributes.parameters.installationState === "installed") {
-      return render(<ConfigScreen ctx={ctx} />);
+  async onBeforeItemsDestroy(items, ctx) {
+    const debugLogger = createDebugLogger(
+      isDebugEnabled(ctx.plugin.attributes.parameters),
+      "index.onBeforeItemsDestroy"
+    );
+    const runtimeMode = getRuntimeMode(ctx.plugin.attributes.parameters);
+
+    if (runtimeMode === "lambda") {
+      debugLogger.log("Skipping Lambda-less delete capture because lambda mode is active");
+      return true;
+    }
+
+    try {
+      const captureResult = await captureDeletedItemsWithoutLambda(items, ctx);
+      debugLogger.log("Lambda-less delete capture completed", captureResult);
+    } catch (error) {
+      debugLogger.error(
+        "Unexpected error in Lambda-less delete capture. Proceeding with deletion (fail-open).",
+        error
+      );
     }
-    return render(<PreInstallConfig ctx={ctx} />);
+
+    return true;
+  },
+  renderConfigScreen(ctx) {
+    const debugLogger = createDebugLogger(
+      isDebugEnabled(ctx.plugin.attributes.parameters),
+      "index.renderConfigScreen"
+    );
+    debugLogger.log("Rendering config screen");
+    return render(<ConfigScreen ctx={ctx} />);
   },
-  itemFormOutlets(model: ItemType, ctx: IntentCtx) {
+  itemFormOutlets(model: ItemType, _ctx: ItemFormOutletsCtx) {
+    const debugLogger = createDebugLogger(
+      isDebugEnabled(_ctx.plugin.attributes.parameters),
+      "index.itemFormOutlets"
+    );
     if (model.attributes.api_key === "record_bin") {
+      debugLogger.log("Registering item form outlet for record_bin model");
       return [
         {
           id: "recordBin",
@@ -47,22 +74,40 @@ connect({
         },
       ];
     }
+
+    debugLogger.log("Skipping item form outlet for model", {
+      modelApiKey: model.attributes.api_key,
+    });
     return [];
   },
   renderItemFormOutlet(outletId, ctx: RenderItemFormOutletCtx) {
-    if (
-      outletId === "recordBin" &&
-      ctx.plugin.attributes.parameters.installationState === "installed"
-    ) {
+    const debugLogger = createDebugLogger(
+      isDebugEnabled(ctx.plugin.attributes.parameters),
+      "index.renderItemFormOutlet"
+    );
+    if (outletId === "recordBin") {
+      debugLogger.log("Rendering record bin outlet");
       render(<BinOutlet ctx={ctx} />);
+      return;
     }
+
+    debugLogger.log("Skipping outlet rendering", {
+      outletId,
+    });
   },
   renderModal(modalId: string, ctx: RenderModalCtx) {
+    const debugLogger = createDebugLogger(
+      isDebugEnabled(ctx.plugin.attributes.parameters),
+      "index.renderModal"
+    );
+    debugLogger.log("Rendering modal", { modalId });
+
     switch (modalId) {
-      case "installationModal":
-        return render(<InstallationModal ctx={ctx} />);
       case "errorModal":
         return render(<ErrorModal ctx={ctx} />);
+      default:
+        debugLogger.warn("Received unknown modal id", { modalId });
+        return undefined;
     }
   },
 });

package/src/react-app-env.d.ts

@@ -1 +1 @@
-/// <reference types="react-scripts" />
+/// <reference types="vite/client" />

package/src/types/types.ts

@@ -1,15 +1,17 @@
 export type errorObject = {
   simplifiedError: {
-    code: string;
+    code?: string;
     details: {
-      code: string;
-      field: string;
-      field_id: string;
-      field_label: string;
-      field_type: string;
-      extraneous_attributes: string[];
-      fullPayload: string;
+      code?: string;
+      field?: string;
+      field_id?: string;
+      field_label?: string;
+      field_type?: string;
+      extraneous_attributes?: string[];
+      fullPayload?: string;
+      [key: string]: unknown;
     };
+    [key: string]: unknown;
   };
   fullErrorPayload: string;
 };
@@ -18,3 +20,29 @@ export type automaticBinCleanupObject = {
   numberOfDays: number;
   timeStamp: string;
 };
+
+export type LambdaConnectionStatus = "connected" | "disconnected";
+
+export type LambdaConnectionPhase =
+  | "finish_installation"
+  | "config_mount"
+  | "config_connect";
+
+export type LambdaConnectionErrorCode =
+  | "INVALID_URL"
+  | "NETWORK"
+  | "TIMEOUT"
+  | "HTTP"
+  | "INVALID_JSON"
+  | "UNEXPECTED_RESPONSE";
+
+export type LambdaConnectionState = {
+  status: LambdaConnectionStatus;
+  endpoint: string;
+  lastCheckedAt: string;
+  lastCheckPhase: LambdaConnectionPhase;
+  errorCode?: LambdaConnectionErrorCode;
+  errorMessage?: string;
+  httpStatus?: number;
+  responseSnippet?: string;
+};

package/src/utils/binCleanup.test.ts

@@ -0,0 +1,107 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import binCleanup from "./binCleanup";
+import { cleanupRecordBinWithoutLambda } from "./lambdaLessCleanup";
+
+vi.mock("./lambdaLessCleanup", () => ({
+  cleanupRecordBinWithoutLambda: vi.fn(),
+}));
+
+const createCtxMock = (
+  parameters: Record<string, unknown>
+): {
+  plugin: {
+    attributes: {
+      parameters: Record<string, unknown>;
+    };
+  };
+  environment: string;
+  currentUserAccessToken: string;
+  updatePluginParameters: ReturnType<typeof vi.fn>;
+} => ({
+  plugin: {
+    attributes: {
+      parameters,
+    },
+  },
+  environment: "main",
+  currentUserAccessToken: "token",
+  updatePluginParameters: vi.fn(),
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.clearAllMocks();
+});
+
+describe("binCleanup", () => {
+  it("uses lambda cleanup when deployment URL is configured", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({ status: 200 });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const ctx = createCtxMock({
+      deploymentURL: "https://record-bin.example.com",
+      automaticBinCleanup: {
+        numberOfDays: 30,
+        timeStamp: "",
+      },
+    });
+
+    await binCleanup(ctx as never);
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).toHaveBeenCalledWith(
+      "https://record-bin.example.com",
+      expect.objectContaining({
+        method: "POST",
+      })
+    );
+    expect(cleanupRecordBinWithoutLambda).not.toHaveBeenCalled();
+    expect(ctx.updatePluginParameters).toHaveBeenCalledTimes(1);
+  });
+
+  it("uses Lambda-less cleanup when no deployment URL is configured", async () => {
+    const fetchMock = vi.fn();
+    vi.stubGlobal("fetch", fetchMock);
+    vi.mocked(cleanupRecordBinWithoutLambda).mockResolvedValue({
+      deletedCount: 2,
+      skipped: false,
+    });
+
+    const ctx = createCtxMock({
+      automaticBinCleanup: {
+        numberOfDays: 10,
+        timeStamp: "",
+      },
+    });
+
+    await binCleanup(ctx as never);
+
+    expect(cleanupRecordBinWithoutLambda).toHaveBeenCalledWith({
+      currentUserAccessToken: "token",
+      environment: "main",
+      numberOfDays: 10,
+    });
+    expect(fetchMock).not.toHaveBeenCalled();
+    expect(ctx.updatePluginParameters).toHaveBeenCalledTimes(1);
+  });
+
+  it("skips cleanup if it already ran today", async () => {
+    const fetchMock = vi.fn();
+    vi.stubGlobal("fetch", fetchMock);
+
+    const today = new Date().toISOString().split("T")[0];
+    const ctx = createCtxMock({
+      deploymentURL: "https://record-bin.example.com",
+      automaticBinCleanup: {
+        numberOfDays: 30,
+        timeStamp: today,
+      },
+    });
+
+    await binCleanup(ctx as never);
+
+    expect(fetchMock).not.toHaveBeenCalled();
+    expect(cleanupRecordBinWithoutLambda).not.toHaveBeenCalled();
+    expect(ctx.updatePluginParameters).not.toHaveBeenCalled();
+  });
+});

package/src/utils/binCleanup.ts

@@ -1,42 +1,90 @@
-import { OnBootPropertiesAndMethods } from "datocms-plugin-sdk";
+import { OnBootCtx } from "datocms-plugin-sdk";
 import { automaticBinCleanupObject } from "../types/types";
+import { createDebugLogger, isDebugEnabled } from "./debugLogger";
+import { getDeploymentUrlFromParameters } from "./getDeploymentUrlFromParameters";
+import { getRuntimeMode } from "./getRuntimeMode";
+import { cleanupRecordBinWithoutLambda } from "./lambdaLessCleanup";
+
+const binCleanup = async (ctx: OnBootCtx) => {
+  const debugLogger = createDebugLogger(
+    isDebugEnabled(ctx.plugin.attributes.parameters),
+    "binCleanup"
+  );
+
+  debugLogger.log("Evaluating daily bin cleanup execution");
 
-const binCleanup = async (ctx: OnBootPropertiesAndMethods) => {
   if (ctx.plugin.attributes.parameters.automaticBinCleanup) {
     const currentTimeStamp = new Date().toISOString().split("T")[0];
+    const cleanupSettings = ctx.plugin.attributes.parameters
+      .automaticBinCleanup as automaticBinCleanupObject;
     if (
-      (
-        ctx.plugin.attributes.parameters
-          .automaticBinCleanup as automaticBinCleanupObject
-      ).timeStamp === currentTimeStamp
+      cleanupSettings.timeStamp === currentTimeStamp
     ) {
+      debugLogger.log("Skipping cleanup because it already ran today", {
+        currentTimeStamp,
+      });
       return;
     }
-    const requestBody = {
-      event_type: "cleanup",
-      numberOfDays: (
+
+    const runtimeMode = getRuntimeMode(ctx.plugin.attributes.parameters);
+
+    if (runtimeMode === "lambda") {
+      const deploymentURL = getDeploymentUrlFromParameters(
         ctx.plugin.attributes.parameters
-          .automaticBinCleanup as automaticBinCleanupObject
-      ).numberOfDays,
-      environment: ctx.environment,
-    };
-
-    const parsedBody = JSON.stringify(requestBody);
-
-    try {
-      await fetch(ctx.plugin.attributes.parameters.vercelURL as URL, {
-        method: "POST",
-        body: parsedBody,
-        headers: { Accept: "*/*", "Content-Type": "application/json" },
+      );
+      if (!deploymentURL) {
+        debugLogger.warn("Skipping cleanup because deployment URL is missing");
+        return;
+      }
+
+      const requestBody = {
+        event_type: "cleanup",
+        numberOfDays: cleanupSettings.numberOfDays,
+        environment: ctx.environment,
+      };
+      const parsedBody = JSON.stringify(requestBody);
+
+      debugLogger.log("Sending lambda cleanup request", {
+        deploymentURL,
+        requestBody,
       });
-    } catch {}
+
+      try {
+        const response = await fetch(deploymentURL, {
+          method: "POST",
+          body: parsedBody,
+          headers: { Accept: "*/*", "Content-Type": "application/json" },
+        });
+        debugLogger.log("Lambda cleanup request finished", {
+          status: response.status,
+        });
+      } catch (error) {
+        debugLogger.error("Lambda cleanup request failed", error);
+      }
+    } else {
+      debugLogger.log("Running cleanup in Lambda-less mode");
+
+      try {
+        const cleanupResult = await cleanupRecordBinWithoutLambda({
+          currentUserAccessToken: ctx.currentUserAccessToken,
+          environment: ctx.environment,
+          numberOfDays: cleanupSettings.numberOfDays,
+        });
+        debugLogger.log("Lambda-less cleanup finished", cleanupResult);
+      } catch (error) {
+        debugLogger.error("Lambda-less cleanup failed", error);
+      }
+    }
 
     const newParameters = { ...ctx.plugin.attributes.parameters };
     (newParameters.automaticBinCleanup as automaticBinCleanupObject).timeStamp =
       currentTimeStamp;
-
     await ctx.updatePluginParameters(newParameters);
+    debugLogger.log("Cleanup timestamp persisted", { currentTimeStamp });
+    return;
   }
+
+  debugLogger.log("Skipping cleanup because automatic cleanup is disabled");
 };
 
 export default binCleanup;

package/src/utils/debugLogger.ts

@@ -0,0 +1,27 @@
+type PluginParameters = Record<string, unknown> | undefined;
+
+type LogMethod = "log" | "warn" | "error";
+
+const LOG_PREFIX = "[record-bin]";
+
+export const isDebugEnabled = (parameters: PluginParameters): boolean =>
+  parameters?.debug === true;
+
+export const createDebugLogger = (debugEnabled: boolean, scope: string) => {
+  const prefix = `${LOG_PREFIX}[${scope}]`;
+
+  const write = (method: LogMethod, ...args: unknown[]) => {
+    if (!debugEnabled) {
+      return;
+    }
+
+    console[method](prefix, ...args);
+  };
+
+  return {
+    enabled: debugEnabled,
+    log: (...args: unknown[]) => write("log", ...args),
+    warn: (...args: unknown[]) => write("warn", ...args),
+    error: (...args: unknown[]) => write("error", ...args),
+  };
+};

package/src/utils/deployProviders.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { DEPLOY_PROVIDER_OPTIONS, PLUGIN_README_URL } from "./deployProviders";
+
+describe("DEPLOY_PROVIDER_OPTIONS", () => {
+  it("contains the expected providers, labels, and urls", () => {
+    expect(DEPLOY_PROVIDER_OPTIONS).toEqual([
+      {
+        provider: "vercel",
+        label: "Vercel",
+        url: "https://vercel.com/new/clone?repository-url=https%3A%2F%2Fgithub.com%2Fmarcelofinamorvieira%2Frecord-bin-lambda-function&env=DATOCMS_FULLACCESS_API_TOKEN&project-name=datocms-record-bin-lambda-function&repo-name=datocms-record-bin-lambda-function",
+      },
+      {
+        provider: "netlify",
+        label: "Netlify",
+        url: "https://app.netlify.com/start/deploy?repository=https://github.com/marcelofinamorvieira/record-bin-lambda-function",
+      },
+      {
+        provider: "cloudflare",
+        label: "Cloudflare",
+        url: "https://github.com/marcelofinamorvieira/record-bin-lambda-function#deploying-on-cloudflare-workers",
+      },
+    ]);
+  });
+});
+
+describe("PLUGIN_README_URL", () => {
+  it("is a valid absolute URL", () => {
+    expect(() => new URL(PLUGIN_README_URL)).not.toThrow();
+    expect(PLUGIN_README_URL).toBe(
+      "https://github.com/datocms/plugins/tree/master/record-bin#readme"
+    );
+  });
+});

package/src/utils/deployProviders.ts

@@ -0,0 +1,28 @@
+export type DeployProvider = "vercel" | "netlify" | "cloudflare";
+
+export type DeployProviderOption = {
+  provider: DeployProvider;
+  label: string;
+  url: string;
+};
+
+export const DEPLOY_PROVIDER_OPTIONS: DeployProviderOption[] = [
+  {
+    provider: "vercel",
+    label: "Vercel",
+    url: "https://vercel.com/new/clone?repository-url=https%3A%2F%2Fgithub.com%2Fmarcelofinamorvieira%2Frecord-bin-lambda-function&env=DATOCMS_FULLACCESS_API_TOKEN&project-name=datocms-record-bin-lambda-function&repo-name=datocms-record-bin-lambda-function",
+  },
+  {
+    provider: "netlify",
+    label: "Netlify",
+    url: "https://app.netlify.com/start/deploy?repository=https://github.com/marcelofinamorvieira/record-bin-lambda-function",
+  },
+  {
+    provider: "cloudflare",
+    label: "Cloudflare",
+    url: "https://github.com/marcelofinamorvieira/record-bin-lambda-function#deploying-on-cloudflare-workers",
+  },
+];
+
+export const PLUGIN_README_URL =
+  "https://github.com/datocms/plugins/tree/master/record-bin#readme";

package/src/utils/getDeploymentUrlFromParameters.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+import { getDeploymentUrlFromParameters } from "./getDeploymentUrlFromParameters";
+
+describe("getDeploymentUrlFromParameters", () => {
+  it("prefers deploymentURL when present", () => {
+    const result = getDeploymentUrlFromParameters({
+      deploymentURL: "https://record-bin.example.com",
+      vercelURL: "https://record-bin.vercel.app",
+    });
+
+    expect(result).toBe("https://record-bin.example.com");
+  });
+
+  it("falls back to legacy vercelURL", () => {
+    const result = getDeploymentUrlFromParameters({
+      vercelURL: "https://record-bin.vercel.app",
+    });
+
+    expect(result).toBe("https://record-bin.vercel.app");
+  });
+
+  it("returns empty string when no URL is configured", () => {
+    expect(getDeploymentUrlFromParameters(undefined)).toBe("");
+    expect(getDeploymentUrlFromParameters({})).toBe("");
+  });
+});

package/src/utils/getDeploymentUrlFromParameters.ts

@@ -0,0 +1,21 @@
+type PluginParameters = Record<string, unknown> | undefined;
+
+const isString = (value: unknown): value is string => typeof value === "string";
+
+export const getDeploymentUrlFromParameters = (
+  parameters: PluginParameters
+): string => {
+  if (!parameters) {
+    return "";
+  }
+
+  if (isString(parameters.deploymentURL) && parameters.deploymentURL.trim()) {
+    return parameters.deploymentURL;
+  }
+
+  if (isString(parameters.vercelURL)) {
+    return parameters.vercelURL;
+  }
+
+  return "";
+};