datocms-plugin-record-bin 2.0.0 → 3.0.0

package/src/utils/restoreError.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it } from "vitest";
+import { errorObject } from "../types/types";
+import {
+  buildRestoreErrorPayload,
+  isRestoreSuccessResponse,
+  parseJsonStringSafely,
+} from "./restoreError";
+
+describe("buildRestoreErrorPayload", () => {
+  it("returns an existing errorObject as-is", () => {
+    const existingError: errorObject = {
+      simplifiedError: {
+        code: "VALIDATION_INVALID",
+        details: {
+          code: "INVALID_FIELD",
+          field: "title",
+        },
+      },
+      fullErrorPayload: "raw-payload",
+    };
+
+    expect(buildRestoreErrorPayload(existingError)).toEqual(existingError);
+  });
+
+  it("extracts simplified error from Dato errors array payload", () => {
+    const result = buildRestoreErrorPayload({
+      errors: [
+        {
+          attributes: {
+            code: "VALIDATION_INVALID",
+            details: {
+              code: "INVALID_FIELD",
+              field: "title",
+            },
+          },
+        },
+      ],
+    });
+
+    expect(result.simplifiedError.code).toBe("VALIDATION_INVALID");
+    expect(result.simplifiedError.details.code).toBe("INVALID_FIELD");
+    expect(result.simplifiedError.details.field).toBe("title");
+    expect(result.fullErrorPayload).toContain("VALIDATION_INVALID");
+  });
+
+  it("extracts simplified error from { error: ... } wrapper payload", () => {
+    const result = buildRestoreErrorPayload(
+      {
+        error: {
+          code: "INVALID_LINK",
+          details: {
+            code: "MISSING_RELATION",
+            message: "Missing linked record",
+          },
+        },
+      },
+      {
+        fullErrorPayload: "raw-response-body",
+      }
+    );
+
+    expect(result.simplifiedError.code).toBe("INVALID_LINK");
+    expect(result.simplifiedError.details.code).toBe("MISSING_RELATION");
+    expect(result.simplifiedError.details.message).toBe("Missing linked record");
+    expect(result.fullErrorPayload).toBe("raw-response-body");
+  });
+
+  it("falls back to UNKNOWN when error payload is unstructured", () => {
+    const result = buildRestoreErrorPayload(
+      { error: {} },
+      { fallbackMessage: "Custom fallback message" }
+    );
+
+    expect(result.simplifiedError.code).toBe("UNKNOWN");
+    expect(result.simplifiedError.details.code).toBe("UNKNOWN");
+    expect(result.simplifiedError.details.message).toBe("Custom fallback message");
+  });
+
+  it("uses plain string payload as fallback message", () => {
+    const result = buildRestoreErrorPayload("Gateway timeout");
+
+    expect(result.simplifiedError.code).toBe("UNKNOWN");
+    expect(result.simplifiedError.details.message).toBe("Gateway timeout");
+  });
+});
+
+describe("parseJsonStringSafely", () => {
+  it("returns undefined for invalid JSON", () => {
+    expect(parseJsonStringSafely("not-json")).toBeUndefined();
+  });
+
+  it("parses valid JSON text", () => {
+    expect(parseJsonStringSafely('{"ok": true}')).toEqual({ ok: true });
+  });
+});
+
+describe("isRestoreSuccessResponse", () => {
+  it("returns true for valid restore success payload", () => {
+    expect(
+      isRestoreSuccessResponse({
+        restoredRecord: { id: "record-id", modelID: "model-id" },
+      })
+    ).toBe(true);
+  });
+
+  it("returns false when restoredRecord shape is missing", () => {
+    expect(isRestoreSuccessResponse({ restoredRecord: { id: "record-id" } })).toBe(
+      false
+    );
+    expect(isRestoreSuccessResponse({})).toBe(false);
+  });
+});

package/src/utils/restoreError.ts

@@ -0,0 +1,221 @@
+import { errorObject } from "../types/types";
+
+const UNKNOWN_ERROR_CODE = "UNKNOWN";
+const DEFAULT_FALLBACK_MESSAGE = "Could not parse restoration error payload.";
+
+type BuildRestoreErrorPayloadOptions = {
+  fullErrorPayload?: string;
+  fallbackMessage?: string;
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  Boolean(value) && typeof value === "object" && !Array.isArray(value);
+
+const isNonEmptyString = (value: unknown): value is string =>
+  typeof value === "string" && value.trim().length > 0;
+
+const serializeUnknownError = (error: unknown): string => {
+  if (error instanceof Error) {
+    return JSON.stringify(error, Object.getOwnPropertyNames(error), 2);
+  }
+
+  try {
+    return JSON.stringify(error, null, 2);
+  } catch {
+    return String(error);
+  }
+};
+
+const isErrorObject = (value: unknown): value is errorObject => {
+  if (!isRecord(value)) {
+    return false;
+  }
+
+  if (typeof value.fullErrorPayload !== "string") {
+    return false;
+  }
+
+  if (!isRecord(value.simplifiedError)) {
+    return false;
+  }
+
+  return isRecord(value.simplifiedError.details);
+};
+
+const buildUnknownSimplifiedError = (
+  error: unknown,
+  fallbackMessage: string
+): errorObject["simplifiedError"] => {
+  const message = isNonEmptyString(error)
+    ? error
+    : error instanceof Error && isNonEmptyString(error.message)
+      ? error.message
+      : fallbackMessage;
+
+  return {
+    code: UNKNOWN_ERROR_CODE,
+    details: {
+      code: UNKNOWN_ERROR_CODE,
+      message,
+    },
+  };
+};
+
+const normalizeSimplifiedErrorRecord = (
+  candidate: Record<string, unknown>,
+  fallbackMessage: string
+): errorObject["simplifiedError"] | undefined => {
+  const candidateDetails = isRecord(candidate.details) ? { ...candidate.details } : {};
+  const hasStructuredShape =
+    isNonEmptyString(candidate.code) || Object.keys(candidateDetails).length > 0;
+
+  if (!hasStructuredShape) {
+    if (isNonEmptyString(candidate.message)) {
+      return {
+        code: UNKNOWN_ERROR_CODE,
+        details: {
+          code: UNKNOWN_ERROR_CODE,
+          message: candidate.message,
+        },
+      };
+    }
+
+    return undefined;
+  }
+
+  const code = isNonEmptyString(candidate.code)
+    ? candidate.code
+    : UNKNOWN_ERROR_CODE;
+  const details: Record<string, unknown> = { ...candidateDetails };
+
+  if (!isNonEmptyString(details.code)) {
+    details.code = code;
+  }
+
+  if (!isNonEmptyString(details.message) && isNonEmptyString(candidate.message)) {
+    details.message = candidate.message;
+  }
+
+  if (
+    Object.keys(details).length === 1 &&
+    details.code === UNKNOWN_ERROR_CODE &&
+    !isNonEmptyString(details.message)
+  ) {
+    details.message = fallbackMessage;
+  }
+
+  return {
+    ...candidate,
+    code,
+    details,
+  } as errorObject["simplifiedError"];
+};
+
+const unwrapErrorWrapper = (error: unknown): unknown => {
+  let current = error;
+
+  while (isRecord(current) && "error" in current) {
+    const nestedError = current.error;
+    if (nestedError === undefined || nestedError === current) {
+      break;
+    }
+
+    current = nestedError;
+  }
+
+  return current;
+};
+
+const extractSimplifiedError = (
+  error: unknown,
+  fallbackMessage: string
+): errorObject["simplifiedError"] => {
+  if (isErrorObject(error)) {
+    return error.simplifiedError;
+  }
+
+  const unwrappedError = unwrapErrorWrapper(error);
+
+  if (isErrorObject(unwrappedError)) {
+    return unwrappedError.simplifiedError;
+  }
+
+  if (isRecord(unwrappedError) && Array.isArray(unwrappedError.errors)) {
+    const firstError = unwrappedError.errors[0];
+    if (isRecord(firstError) && isRecord(firstError.attributes)) {
+      const normalizedAttributes = normalizeSimplifiedErrorRecord(
+        firstError.attributes,
+        fallbackMessage
+      );
+      if (normalizedAttributes) {
+        return normalizedAttributes;
+      }
+    }
+  }
+
+  if (isRecord(unwrappedError)) {
+    const normalizedError = normalizeSimplifiedErrorRecord(
+      unwrappedError,
+      fallbackMessage
+    );
+    if (normalizedError) {
+      return normalizedError;
+    }
+  }
+
+  return buildUnknownSimplifiedError(unwrappedError, fallbackMessage);
+};
+
+export const parseJsonStringSafely = (
+  rawResponseText: string
+): unknown | undefined => {
+  if (!isNonEmptyString(rawResponseText)) {
+    return undefined;
+  }
+
+  try {
+    return JSON.parse(rawResponseText);
+  } catch {
+    return undefined;
+  }
+};
+
+export const buildRestoreErrorPayload = (
+  error: unknown,
+  options: BuildRestoreErrorPayloadOptions = {}
+): errorObject => {
+  const { fullErrorPayload, fallbackMessage = DEFAULT_FALLBACK_MESSAGE } = options;
+
+  if (isErrorObject(error) && !isNonEmptyString(fullErrorPayload)) {
+    return error;
+  }
+
+  return {
+    simplifiedError: extractSimplifiedError(error, fallbackMessage),
+    fullErrorPayload: fullErrorPayload ?? serializeUnknownError(error),
+  };
+};
+
+export type RestoreSuccessResponse = {
+  restoredRecord: {
+    id: string;
+    modelID: string;
+  };
+};
+
+export const isRestoreSuccessResponse = (
+  payload: unknown
+): payload is RestoreSuccessResponse => {
+  if (!isRecord(payload)) {
+    return false;
+  }
+
+  if (!isRecord(payload.restoredRecord)) {
+    return false;
+  }
+
+  return (
+    isNonEmptyString(payload.restoredRecord.id) &&
+    isNonEmptyString(payload.restoredRecord.modelID)
+  );
+};

package/src/utils/verifyLambdaHealth.test.ts

@@ -0,0 +1,248 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  LambdaHealthCheckError,
+  verifyLambdaHealth,
+} from "./verifyLambdaHealth";
+
+const expectRejected = async (
+  promise: Promise<unknown>
+): Promise<LambdaHealthCheckError> => {
+  try {
+    await promise;
+    throw new Error("Expected promise to reject");
+  } catch (error) {
+    return error as LambdaHealthCheckError;
+  }
+};
+
+afterEach(() => {
+  vi.useRealTimers();
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+});
+
+describe("verifyLambdaHealth", () => {
+  it("accepts a valid health handshake response", async () => {
+    const fetchMock = vi.fn(async () =>
+      new Response(
+        JSON.stringify({
+          ok: true,
+          mpi: {
+            message: "DATOCMS_RECORD_BIN_LAMBDA_PONG",
+            version: "2026-02-25",
+          },
+          service: "record-bin-lambda-function",
+          status: "ready",
+        }),
+        { status: 200 }
+      )
+    );
+    vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
+
+    const result = await verifyLambdaHealth({
+      baseUrl: "https://record-bin.vercel.app/",
+      environment: "main",
+      phase: "finish_installation",
+    });
+
+    expect(result.endpoint).toBe(
+      "https://record-bin.vercel.app/api/datocms/plugin-health"
+    );
+    expect(result.normalizedBaseUrl).toBe("https://record-bin.vercel.app");
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(fetchMock).toHaveBeenCalledWith(
+      "https://record-bin.vercel.app/api/datocms/plugin-health",
+      expect.objectContaining({
+        method: "POST",
+        headers: {
+          Accept: "*/*",
+          "Content-Type": "application/json",
+        },
+      })
+    );
+
+    const requestInit = fetchMock.mock.calls[0][1] as RequestInit;
+    const payload = JSON.parse(requestInit.body as string) as {
+      mpi: { phase: string };
+    };
+    expect(payload.mpi.phase).toBe("finish_installation");
+  });
+
+  it("accepts a Netlify deployment URL", async () => {
+    const fetchMock = vi.fn(async () =>
+      new Response(
+        JSON.stringify({
+          ok: true,
+          mpi: {
+            message: "DATOCMS_RECORD_BIN_LAMBDA_PONG",
+            version: "2026-02-25",
+          },
+          service: "record-bin-lambda-function",
+          status: "ready",
+        }),
+        { status: 200 }
+      )
+    );
+    vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
+
+    const result = await verifyLambdaHealth({
+      baseUrl: "https://record-bin.netlify.app/",
+      environment: "main",
+      phase: "finish_installation",
+    });
+
+    expect(result.endpoint).toBe(
+      "https://record-bin.netlify.app/api/datocms/plugin-health"
+    );
+    expect(result.normalizedBaseUrl).toBe("https://record-bin.netlify.app");
+  });
+
+  it("accepts a hostname-only URL by prepending https", async () => {
+    const fetchMock = vi.fn(async () =>
+      new Response(
+        JSON.stringify({
+          ok: true,
+          mpi: {
+            message: "DATOCMS_RECORD_BIN_LAMBDA_PONG",
+            version: "2026-02-25",
+          },
+          service: "record-bin-lambda-function",
+          status: "ready",
+        }),
+        { status: 200 }
+      )
+    );
+    vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
+
+    const result = await verifyLambdaHealth({
+      baseUrl: "melodious-chebakia-9da33e.netlify.app",
+      environment: "main",
+      phase: "finish_installation",
+    });
+
+    expect(result.endpoint).toBe(
+      "https://melodious-chebakia-9da33e.netlify.app/api/datocms/plugin-health"
+    );
+    expect(result.normalizedBaseUrl).toBe(
+      "https://melodious-chebakia-9da33e.netlify.app"
+    );
+    expect(fetchMock).toHaveBeenCalledWith(
+      "https://melodious-chebakia-9da33e.netlify.app/api/datocms/plugin-health",
+      expect.any(Object)
+    );
+  });
+
+  it("fails when URL is invalid", async () => {
+    const error = await expectRejected(
+      verifyLambdaHealth({
+        baseUrl: "not-a-valid-url",
+        environment: "main",
+        phase: "finish_installation",
+      })
+    );
+
+    expect(error).toBeInstanceOf(LambdaHealthCheckError);
+    expect(error.code).toBe("INVALID_URL");
+  });
+
+  it("fails when request times out", async () => {
+    vi.useFakeTimers();
+    const fetchMock = vi.fn(
+      (_input: RequestInfo | URL, init?: RequestInit): Promise<Response> =>
+        new Promise((_resolve, reject) => {
+          init?.signal?.addEventListener("abort", () => {
+            const abortError = new Error("aborted");
+            abortError.name = "AbortError";
+            reject(abortError);
+          });
+        })
+    );
+    vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
+
+    const promise = expectRejected(
+      verifyLambdaHealth({
+        baseUrl: "https://record-bin.vercel.app",
+        environment: "main",
+        phase: "config_mount",
+      })
+    );
+
+    await vi.advanceTimersByTimeAsync(8000);
+    const error = await promise;
+
+    expect(error.code).toBe("TIMEOUT");
+    expect(error.message).toContain("timed out");
+  });
+
+  it("fails when endpoint returns non-200 status", async () => {
+    const fetchMock = vi.fn(async () =>
+      new Response(
+        JSON.stringify({
+          ok: false,
+          error: {
+            code: "INVALID_MPI_MESSAGE",
+            message: "Expected DATOCMS_RECORD_BIN_PLUGIN_PING",
+          },
+        }),
+        { status: 400 }
+      )
+    );
+    vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
+
+    const error = await expectRejected(
+      verifyLambdaHealth({
+        baseUrl: "https://record-bin.vercel.app",
+        environment: "main",
+        phase: "config_mount",
+      })
+    );
+
+    expect(error.code).toBe("HTTP");
+    expect(error.httpStatus).toBe(400);
+    expect(error.message).toContain("INVALID_MPI_MESSAGE");
+  });
+
+  it("fails when endpoint returns invalid JSON", async () => {
+    const fetchMock = vi.fn(async () => new Response("not-json", { status: 200 }));
+    vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
+
+    const error = await expectRejected(
+      verifyLambdaHealth({
+        baseUrl: "https://record-bin.vercel.app",
+        environment: "main",
+        phase: "config_mount",
+      })
+    );
+
+    expect(error.code).toBe("INVALID_JSON");
+  });
+
+  it("fails when JSON does not match expected MPI response", async () => {
+    const fetchMock = vi.fn(async () =>
+      new Response(
+        JSON.stringify({
+          ok: true,
+          mpi: {
+            message: "WRONG_MESSAGE",
+            version: "2026-02-25",
+          },
+          service: "record-bin-lambda-function",
+          status: "ready",
+        }),
+        { status: 200 }
+      )
+    );
+    vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
+
+    const error = await expectRejected(
+      verifyLambdaHealth({
+        baseUrl: "https://record-bin.vercel.app",
+        environment: "main",
+        phase: "config_mount",
+      })
+    );
+
+    expect(error.code).toBe("UNEXPECTED_RESPONSE");
+    expect(error.message).toContain("MPI PONG");
+  });
+});