@uniformdev/canvas-next-rsc 19.69.0 → 19.73.0

package/dist/handler.mjs

@@ -0,0 +1,682 @@
+// src/handler/createPreviewGETRouteHandler.ts
+import {
+  CANVAS_DRAFT_STATE as CANVAS_DRAFT_STATE2,
+  IN_CONTEXT_EDITOR_PLAYGROUND_QUERY_STRING_PARAM,
+  IN_CONTEXT_EDITOR_QUERY_STRING_PARAM as IN_CONTEXT_EDITOR_QUERY_STRING_PARAM2
+} from "@uniformdev/canvas";
+import { draftMode as draftMode2 } from "next/headers";
+import { redirect } from "next/navigation";
+
+// src/utils/route.ts
+import {
+  CANVAS_DRAFT_STATE,
+  CANVAS_EDITOR_STATE,
+  CANVAS_PUBLISHED_STATE
+} from "@uniformdev/canvas";
+import { getBaseUrl, getServerConfig as getServerConfig2, resolvePath } from "@uniformdev/canvas-next-rsc-shared";
+import { getTargetVariableExpandedUrl } from "@uniformdev/redirect";
+
+// src/config/helpers.ts
+import { getServerConfig } from "@uniformdev/canvas-next-rsc-shared";
+
+// src/utils/draft.ts
+import { IN_CONTEXT_EDITOR_QUERY_STRING_PARAM } from "@uniformdev/canvas";
+import { draftMode } from "next/headers";
+var isDraftModeEnabled = ({
+  searchParams
+}) => {
+  if (isDevelopmentEnvironment()) {
+    return isIncontextEditingEnabled({ searchParams });
+  }
+  let draftModeEnabled = false;
+  try {
+    draftModeEnabled = draftMode().isEnabled;
+  } catch (e) {
+  }
+  return draftModeEnabled || isIncontextEditingEnabled({ searchParams });
+};
+var isIncontextEditingEnabled = ({
+  searchParams
+}) => {
+  const containsKey = typeof (searchParams == null ? void 0 : searchParams[IN_CONTEXT_EDITOR_QUERY_STRING_PARAM]) !== "undefined";
+  return containsKey;
+};
+var isOnVercelPreviewEnvironment = () => {
+  return process.env.VERCEL_ENV === "preview";
+};
+var isDevelopmentEnvironment = () => {
+  return process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test";
+};
+
+// src/config/helpers.ts
+var shouldCacheBeDisabled = (options) => {
+  if (isDraftModeEnabled(options)) {
+    return { disabled: true, reason: "DRAFT" };
+  }
+  if (isIncontextEditingEnabled(options)) {
+    return { disabled: true, reason: "INCONTEXT" };
+  }
+  if (isDevelopmentEnvironment()) {
+    return { disabled: true, reason: "DEV" };
+  }
+  return {
+    disabled: false,
+    reason: void 0
+  };
+};
+var getCanvasCacheStrategy = (options) => {
+  const { disabled, reason } = shouldCacheBeDisabled(options);
+  const config = getServerConfig();
+  if (disabled) {
+    if (reason === "DEV" && config.canvasCache) {
+      console.warn("Canvas cache (disabled) has been overridden by canvasCache config.");
+      return config.canvasCache;
+    }
+    return {
+      type: "no-cache"
+    };
+  }
+  if (config.canvasCache) {
+    return config.canvasCache;
+  }
+  return {
+    type: "force-cache"
+  };
+};
+
+// src/env/index.ts
+var env = {
+  getProjectId: () => {
+    return process.env.UNIFORM_PROJECT_ID;
+  },
+  getApiKey: () => {
+    return process.env.UNIFORM_API_KEY;
+  },
+  getApiHost: () => {
+    return process.env.UNIFORM_API_HOST || process.env.UNIFORM_CLI_BASE_URL;
+  },
+  getEdgeApiHost: () => {
+    return process.env.UNIFORM_EDGE_API_HOST || process.env.UNIFORM_CLI_BASE_EDGE_URL;
+  }
+};
+
+// src/utils/tag.ts
+var buildPathTag = (path) => {
+  const actualPath = path.startsWith("/") ? path : `/${path}`;
+  return `path:${actualPath}`.toLowerCase();
+};
+var buildCompositionTag = (compositionId) => {
+  return `composition:${compositionId}`.toLowerCase();
+};
+
+// src/clients/shared.ts
+var determineFetchCacheOptions = (mode) => {
+  let cache = void 0;
+  let revalidate = void 0;
+  if (mode.type === "revalidate") {
+    cache = void 0;
+    revalidate = mode.interval;
+  } else {
+    cache = mode.type;
+  }
+  return {
+    cache,
+    revalidate
+  };
+};
+
+// src/clients/routeClient.ts
+import { RouteClient } from "@uniformdev/canvas";
+var getRouteClient = (options) => {
+  const client = new RouteClient({
+    projectId: env.getProjectId(),
+    apiKey: env.getApiKey(),
+    edgeApiHost: env.getEdgeApiHost(),
+    fetch: (req, init) => {
+      let requestedUrl;
+      if (typeof req === "string") {
+        requestedUrl = new URL(req);
+      } else if (req instanceof URL) {
+        requestedUrl = req;
+      } else {
+        requestedUrl = new URL(req.url);
+      }
+      const tags = [];
+      if (requestedUrl) {
+        const pathKey = "path";
+        const path = requestedUrl.searchParams.get(pathKey);
+        if (path) {
+          const pieces = path.split("/");
+          for (let i = 0; i < pieces.length; i++) {
+            const segmentPieces = pieces.slice(0, i + 1);
+            const segment = segmentPieces.join("/");
+            tags.push(buildPathTag(segment));
+          }
+        }
+      }
+      const { cache, revalidate } = determineFetchCacheOptions(options.cache);
+      return fetch(req, {
+        ...init,
+        headers: {
+          ...init == null ? void 0 : init.headers,
+          "x-bypass-cache": "true"
+        },
+        cache,
+        next: {
+          revalidate,
+          tags: tags.length ? tags : void 0
+        }
+      });
+    }
+  });
+  return client;
+};
+var getDefaultRouteClient = ({ searchParams }) => {
+  return getRouteClient({
+    cache: getCanvasCacheStrategy({
+      searchParams
+    })
+  });
+};
+
+// src/utils/route.ts
+var retrieveRouteByPath = async ({
+  path,
+  state,
+  searchParams
+}) => {
+  var _a;
+  const client = getDefaultRouteClient({
+    searchParams
+  });
+  return await client.getRoute({
+    path,
+    state,
+    withComponentIDs: true,
+    withContentSourceMap: isOnVercelPreviewEnvironment() && ((_a = getServerConfig2().experimental) == null ? void 0 : _a.vercelVisualEditing)
+  });
+};
+var resolveRedirectHref = (resolveResult, path) => {
+  let href;
+  if (resolveResult.redirect.targetProjectMapNodeId) {
+    const requestUrl = `${getBaseUrl()}${path}`;
+    const expandedUrl = getTargetVariableExpandedUrl(requestUrl, resolveResult.redirect);
+    const url = new URL(expandedUrl);
+    href = url.pathname;
+  } else {
+    href = resolveResult.redirect.targetUrl;
+  }
+  return href;
+};
+
+// src/handler/createPreviewGETRouteHandler.ts
+var getQueryParam = (req, paramName) => {
+  const value = req.nextUrl.searchParams.get(paramName);
+  if (typeof value === "undefined") {
+    return void 0;
+  }
+  return Array.isArray(value) ? value[0] : value;
+};
+var createPreviewGETRouteHandler = (options) => {
+  return async (request) => {
+    const isConfigCheck = getQueryParam(request, "is_config_check") === "true";
+    if (isConfigCheck) {
+      return Response.json(
+        {
+          hasPlayground: Boolean(options == null ? void 0 : options.playgroundPath),
+          isUsingCustomFullPathResolver: false
+        },
+        {
+          headers: {
+            "Access-Control-Allow-Origin": process.env.UNIFORM_CLI_BASE_URL || "http://uniform.app"
+          }
+        }
+      );
+    }
+    if (request.headers.get("sec-fetch-mode") === "no-cors") {
+      return new Response(null, { status: 204 });
+    }
+    if (!process.env.UNIFORM_PREVIEW_SECRET) {
+      return new Response("No preview secret is configured", { status: 401 });
+    }
+    const { searchParams } = new URL(request.url);
+    const secret = searchParams.get("secret");
+    const path = searchParams.get("path");
+    const isPlayground = searchParams.get(IN_CONTEXT_EDITOR_PLAYGROUND_QUERY_STRING_PARAM) === "true";
+    const id = searchParams.get("id");
+    if (secret !== process.env.UNIFORM_PREVIEW_SECRET) {
+      return new Response("Invalid preview secret", { status: 401 });
+    }
+    if (!isPlayground) {
+      if (!path) {
+        return new Response("Path not provided", { status: 401 });
+      }
+      const resolveResult = await retrieveRouteByPath({
+        path,
+        state: CANVAS_DRAFT_STATE2,
+        searchParams: {
+          // about to be in draft mode so pretend for now.
+          [IN_CONTEXT_EDITOR_QUERY_STRING_PARAM2]: "true"
+        }
+      });
+      draftMode2().enable();
+      if (resolveResult.type === "redirect") {
+        const href = resolveRedirectHref(resolveResult, path);
+        if (resolveResult.redirect.targetProjectMapNodeId) {
+          redirect(`${href}?${IN_CONTEXT_EDITOR_QUERY_STRING_PARAM2}=true`);
+        } else {
+          redirect(href);
+        }
+      }
+      if (resolveResult.type === "notFound") {
+        return new Response("Invalid path", { status: 401 });
+      }
+      redirect(`${path}?${IN_CONTEXT_EDITOR_QUERY_STRING_PARAM2}=true`);
+    } else {
+      if (!(options == null ? void 0 : options.playgroundPath)) {
+        return new Response("No playground path is configured", { status: 401 });
+      }
+      draftMode2().enable();
+      redirect(`${options.playgroundPath}?id=${id}&${IN_CONTEXT_EDITOR_QUERY_STRING_PARAM2}=true`);
+    }
+  };
+};
+
+// src/handler/createPreviewOPTIONSRouteHandler.ts
+var createPreviewOPTIONSRouteHandler = () => {
+  return async () => {
+    return new Response(null, {
+      headers: {
+        "Access-Control-Allow-Origin": process.env.UNIFORM_CLI_BASE_URL || "http://uniform.app",
+        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+        "Access-Control-Allow-Headers": "*"
+      }
+    });
+  };
+};
+
+// src/handler/createPreviewPOSTRouteHandler.ts
+import { revalidateTag } from "next/cache";
+
+// src/handler/helpers.ts
+import { getServerConfig as getServerConfig3 } from "@uniformdev/canvas-next-rsc-shared";
+import { parseConnectionString } from "@vercel/edge-config";
+import { Webhook } from "svix";
+
+// src/clients/projectMapClient.ts
+import { ProjectMapClient } from "@uniformdev/project-map";
+var getProjectMapClient = (options) => {
+  const manifestClient = new ProjectMapClient({
+    apiHost: env.getApiHost(),
+    apiKey: env.getApiKey(),
+    projectId: env.getProjectId(),
+    fetch: (req, init) => {
+      const { cache, revalidate } = determineFetchCacheOptions(options.cache);
+      return fetch(req, {
+        ...init,
+        headers: {
+          ...init == null ? void 0 : init.headers,
+          "x-bypass-cache": "true"
+        },
+        cache,
+        next: {
+          revalidate
+        }
+      });
+    }
+  });
+  return manifestClient;
+};
+
+// src/handler/helpers.ts
+var isSvixMessage = async (request) => {
+  const requiredHeaders = ["svix-id", "svix-timestamp", "svix-signature"];
+  const hasAllRequiredHeaders = requiredHeaders.every((header) => request.headers.has(header));
+  if (!hasAllRequiredHeaders) {
+    return {
+      looksLikeMessage: false,
+      validation: false
+    };
+  }
+  if (typeof process.env.UNIFORM_WEBHOOK_SECRET !== "undefined") {
+    const payload = await request.clone().text();
+    const headers = Object.fromEntries(request.headers.entries());
+    const wh = new Webhook(process.env.UNIFORM_WEBHOOK_SECRET);
+    try {
+      wh.verify(payload, headers);
+    } catch (err) {
+      return {
+        looksLikeMessage: true,
+        validation: false
+      };
+    }
+  }
+  return {
+    looksLikeMessage: true,
+    validation: true
+  };
+};
+var processCompositionChange = async (compositionId) => {
+  const projectMapClient = getProjectMapClient({
+    cache: {
+      type: "no-cache"
+    }
+  });
+  const { nodes } = await projectMapClient.getNodes({
+    compositionId
+  });
+  const tags = [];
+  if (nodes) {
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      await processEdgeConfigChange({
+        source_url: node.path
+      });
+      tags.push(...buildProjectMapNodePaths(node.path));
+    }
+  }
+  tags.push(buildCompositionTag(compositionId));
+  return {
+    tags
+  };
+};
+var buildProjectMapNodePaths = (path) => {
+  const tags = [];
+  const isDynamic = path.includes(":");
+  if (!isDynamic) {
+    tags.push(buildPathTag(path));
+  } else {
+    const pieces = path.split("/");
+    const invalidatePieces = [];
+    for (let j = 0; j < pieces.length; j++) {
+      const piece = pieces[j];
+      if (piece.startsWith(":")) {
+        break;
+      }
+      invalidatePieces.push(piece);
+    }
+    const toInvalidate = invalidatePieces.join("/");
+    tags.push(buildPathTag(toInvalidate));
+  }
+  return tags;
+};
+var getPathName = (url) => {
+  try {
+    const { pathname } = new URL(url);
+    return pathname;
+  } catch (e) {
+    return url;
+  }
+};
+var processRedirectChange = async (sourceUrl) => {
+  const tags = [];
+  const pathName = getPathName(sourceUrl);
+  tags.push(buildPathTag(pathName));
+  return {
+    tags
+  };
+};
+var processEdgeConfigChange = async ({ source_url }) => {
+  var _a, _b;
+  if (!process.env.UNIFORM_VERCEL_EDGE_CONFIG_TOKEN) {
+    console.warn("UNIFORM_VERCEL_EDGE_CONFIG_TOKEN is not set, skipping edge redirect upsert");
+    return;
+  }
+  const config = getServerConfig3();
+  const routeClient = getRouteClient({
+    cache: {
+      type: "no-cache"
+    }
+  });
+  const route = await routeClient.getRoute({
+    path: source_url
+  });
+  let valueToStore = void 0;
+  const shouldSaveRedirect = route.type === "redirect" && ((_a = config.experimental) == null ? void 0 : _a.edgeRedirects);
+  const shouldSaveComposition = route.type === "composition" && ((_b = config.experimental) == null ? void 0 : _b.edgeCompositions);
+  if (shouldSaveRedirect || shouldSaveComposition) {
+    valueToStore = route;
+  }
+  const sourcePath = getPathName(source_url);
+  const soucrcePathKey = buildPathTag(sourcePath);
+  const { id } = parseConnectionString(process.env.EDGE_CONFIG) || {};
+  if (!id) {
+    console.warn("EDGE_CONFIG is not set or not a connection string, skipping edge redirect upsert");
+    return;
+  }
+  const url = new URL(`https://api.vercel.com/v1/edge-config/${id}/items`);
+  if (process.env.UNIFORM_VERCEL_EDGE_CONFIG_TEAM_ID) {
+    url.searchParams.set("teamId", process.env.UNIFORM_VERCEL_EDGE_CONFIG_TEAM_ID);
+  }
+  const response = await fetch(url.toString(), {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${process.env.UNIFORM_VERCEL_EDGE_CONFIG_TOKEN}`
+    },
+    body: JSON.stringify({
+      items: [
+        {
+          operation: valueToStore ? "upsert" : "delete",
+          key: soucrcePathKey.replace(/\W+/g, ""),
+          value: valueToStore != null ? valueToStore : null
+        }
+      ]
+    })
+  });
+  if (!response.ok) {
+    console.warn(`Failed to upsert edge redirect for ${source_url}`, await response.text());
+  }
+};
+
+// src/handler/messages/handleCompositionChanged.ts
+import { CompositionChangedDefinition } from "@uniformdev/webhooks";
+var handleCompositionChanged = async (body) => {
+  const parsed = CompositionChangedDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  return processCompositionChange(parsed.data.id);
+};
+
+// src/handler/messages/handleCompositionDeleted.ts
+import { CompositionDeletedDefinition } from "@uniformdev/webhooks";
+var handleCompositionDeleted = async (body) => {
+  const parsed = CompositionDeletedDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  return processCompositionChange(parsed.data.id);
+};
+
+// src/handler/messages/handleCompositionPublished.ts
+import { CompositionPublishedDefinition } from "@uniformdev/webhooks";
+var handleCompositionPublished = async (body) => {
+  const parsed = CompositionPublishedDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  return processCompositionChange(parsed.data.id);
+};
+
+// src/handler/messages/handleManifestPublished.ts
+import { ManifestPublishedDefinition } from "@uniformdev/webhooks";
+var handleManifestPublished = async (body) => {
+  const parsed = ManifestPublishedDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  return {
+    tags: ["manifest"]
+  };
+};
+
+// src/handler/messages/handleProjectMapNodeDelete.ts
+import { getServerConfig as getServerConfig4 } from "@uniformdev/canvas-next-rsc-shared";
+import { ProjectMapNodeDeleteDefinition } from "@uniformdev/webhooks";
+var handleProjectMapNodeDelete = async (body) => {
+  var _a;
+  const parsed = ProjectMapNodeDeleteDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  const tags = [];
+  tags.push(...buildProjectMapNodePaths(parsed.data.path));
+  const config = getServerConfig4();
+  if ((_a = config.experimental) == null ? void 0 : _a.edgeCompositions) {
+    await processEdgeConfigChange({
+      source_url: parsed.data.path
+    });
+  }
+  return {
+    tags
+  };
+};
+
+// src/handler/messages/handleProjectMapNodeInsert.ts
+import { getServerConfig as getServerConfig5 } from "@uniformdev/canvas-next-rsc-shared";
+import { ProjectMapNodeInsertDefinition } from "@uniformdev/webhooks";
+var handleProjectMapNodeInsert = async (body) => {
+  var _a;
+  const parsed = ProjectMapNodeInsertDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  const tags = [];
+  tags.push(...buildProjectMapNodePaths(parsed.data.path));
+  const config = getServerConfig5();
+  if ((_a = config.experimental) == null ? void 0 : _a.edgeCompositions) {
+    await processEdgeConfigChange({
+      source_url: parsed.data.path
+    });
+  }
+  return {
+    tags
+  };
+};
+
+// src/handler/messages/handleProjectMapNodeUpdate.ts
+import { getServerConfig as getServerConfig6 } from "@uniformdev/canvas-next-rsc-shared";
+import { ProjectMapNodeUpdateDefinition } from "@uniformdev/webhooks";
+var handleProjectMapNodeUpdate = async (body) => {
+  var _a;
+  const parsed = ProjectMapNodeUpdateDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  const tags = [];
+  tags.push(...buildProjectMapNodePaths(parsed.data.path));
+  tags.push(...buildProjectMapNodePaths(parsed.data.previous_path));
+  const config = getServerConfig6();
+  if ((_a = config.experimental) == null ? void 0 : _a.edgeCompositions) {
+    await processEdgeConfigChange({
+      source_url: parsed.data.path
+    });
+  }
+  return {
+    tags
+  };
+};
+
+// src/handler/messages/handleRedirectDelete.ts
+import { getServerConfig as getServerConfig7 } from "@uniformdev/canvas-next-rsc-shared";
+import { RedirectDeleteDefinition } from "@uniformdev/webhooks";
+var handleRedirectDelete = async (body) => {
+  var _a;
+  const parsed = RedirectDeleteDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  const config = getServerConfig7();
+  if ((_a = config.experimental) == null ? void 0 : _a.edgeRedirects) {
+    await processEdgeConfigChange(parsed.data);
+  }
+  return processRedirectChange(parsed.data.source_url);
+};
+
+// src/handler/messages/handleRedirectInsert.ts
+import { getServerConfig as getServerConfig8 } from "@uniformdev/canvas-next-rsc-shared";
+import { RedirectInsertDefinition } from "@uniformdev/webhooks";
+var handleRedirectInsert = async (body) => {
+  var _a;
+  const parsed = RedirectInsertDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  const config = getServerConfig8();
+  if ((_a = config.experimental) == null ? void 0 : _a.edgeRedirects) {
+    await processEdgeConfigChange(parsed.data);
+  }
+  return processRedirectChange(parsed.data.source_url);
+};
+
+// src/handler/messages/handleRedirectUpdate.ts
+import { getServerConfig as getServerConfig9 } from "@uniformdev/canvas-next-rsc-shared";
+import { RedirectUpdateDefinition } from "@uniformdev/webhooks";
+var handleRedirectUpdate = async (body) => {
+  var _a;
+  const parsed = RedirectUpdateDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  const config = getServerConfig9();
+  if ((_a = config.experimental) == null ? void 0 : _a.edgeRedirects) {
+    await processEdgeConfigChange(parsed.data);
+  }
+  return processRedirectChange(parsed.data.source_url);
+};
+
+// src/handler/createPreviewPOSTRouteHandler.ts
+var createPreviewPOSTRouteHandler = () => {
+  return async (request) => {
+    const { looksLikeMessage, validation } = await isSvixMessage(request);
+    if (looksLikeMessage) {
+      if (!validation) {
+        return new Response("This looks like a webhook request but the validation failed.", { status: 401 });
+      }
+      return handleSvixMessage(request);
+    }
+    return new Response("This is not a webhook request.", { status: 401 });
+  };
+};
+var handleSvixMessage = async (request) => {
+  const handlers = [
+    handleProjectMapNodeUpdate,
+    handleProjectMapNodeInsert,
+    handleProjectMapNodeDelete,
+    handleCompositionDeleted,
+    handleCompositionChanged,
+    handleCompositionPublished,
+    handleRedirectInsert,
+    handleRedirectUpdate,
+    handleRedirectDelete,
+    handleManifestPublished
+  ];
+  let tags = void 0;
+  const jsonBody = await request.json();
+  for (let i = 0; i < handlers.length; i++) {
+    const handler = handlers[i];
+    const result = await handler(jsonBody);
+    if (result) {
+      tags = result.tags;
+      break;
+    }
+  }
+  if (tags == null ? void 0 : tags.length) {
+    for (let i = 0; i < tags.length; i++) {
+      const tag = tags[i];
+      revalidateTag(tag);
+    }
+  }
+  return new Response(
+    JSON.stringify({
+      handled: typeof tags !== "undefined",
+      tags
+    })
+  );
+};
+export {
+  createPreviewGETRouteHandler,
+  createPreviewOPTIONSRouteHandler,
+  createPreviewPOSTRouteHandler
+};