@uniformdev/canvas-next-rsc 19.69.0 → 19.73.0

package/dist/handler.js

@@ -1,2 +1,703 @@
-export { createPreviewGETRouteHandler } from './handler/createPreviewGETRouteHandler';
-export { createPreviewPOSTRouteHandler } from './handler/createPreviewPOSTRouteHandler';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/handler.ts
+var handler_exports = {};
+__export(handler_exports, {
+  createPreviewGETRouteHandler: () => createPreviewGETRouteHandler,
+  createPreviewOPTIONSRouteHandler: () => createPreviewOPTIONSRouteHandler,
+  createPreviewPOSTRouteHandler: () => createPreviewPOSTRouteHandler
+});
+module.exports = __toCommonJS(handler_exports);
+
+// src/handler/createPreviewGETRouteHandler.ts
+var import_canvas4 = require("@uniformdev/canvas");
+var import_headers2 = require("next/headers");
+var import_navigation = require("next/navigation");
+
+// src/utils/route.ts
+var import_canvas3 = require("@uniformdev/canvas");
+var import_canvas_next_rsc_shared2 = require("@uniformdev/canvas-next-rsc-shared");
+var import_redirect = require("@uniformdev/redirect");
+
+// src/config/helpers.ts
+var import_canvas_next_rsc_shared = require("@uniformdev/canvas-next-rsc-shared");
+
+// src/utils/draft.ts
+var import_canvas = require("@uniformdev/canvas");
+var import_headers = require("next/headers");
+var isDraftModeEnabled = ({
+  searchParams
+}) => {
+  if (isDevelopmentEnvironment()) {
+    return isIncontextEditingEnabled({ searchParams });
+  }
+  let draftModeEnabled = false;
+  try {
+    draftModeEnabled = (0, import_headers.draftMode)().isEnabled;
+  } catch (e) {
+  }
+  return draftModeEnabled || isIncontextEditingEnabled({ searchParams });
+};
+var isIncontextEditingEnabled = ({
+  searchParams
+}) => {
+  const containsKey = typeof (searchParams == null ? void 0 : searchParams[import_canvas.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 = (0, import_canvas_next_rsc_shared.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
+var import_canvas2 = require("@uniformdev/canvas");
+var getRouteClient = (options) => {
+  const client = new import_canvas2.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 = (0, import_canvas_next_rsc_shared2.getServerConfig)().experimental) == null ? void 0 : _a.vercelVisualEditing)
+  });
+};
+var resolveRedirectHref = (resolveResult, path) => {
+  let href;
+  if (resolveResult.redirect.targetProjectMapNodeId) {
+    const requestUrl = `${(0, import_canvas_next_rsc_shared2.getBaseUrl)()}${path}`;
+    const expandedUrl = (0, import_redirect.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(import_canvas4.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: import_canvas4.CANVAS_DRAFT_STATE,
+        searchParams: {
+          // about to be in draft mode so pretend for now.
+          [import_canvas4.IN_CONTEXT_EDITOR_QUERY_STRING_PARAM]: "true"
+        }
+      });
+      (0, import_headers2.draftMode)().enable();
+      if (resolveResult.type === "redirect") {
+        const href = resolveRedirectHref(resolveResult, path);
+        if (resolveResult.redirect.targetProjectMapNodeId) {
+          (0, import_navigation.redirect)(`${href}?${import_canvas4.IN_CONTEXT_EDITOR_QUERY_STRING_PARAM}=true`);
+        } else {
+          (0, import_navigation.redirect)(href);
+        }
+      }
+      if (resolveResult.type === "notFound") {
+        return new Response("Invalid path", { status: 401 });
+      }
+      (0, import_navigation.redirect)(`${path}?${import_canvas4.IN_CONTEXT_EDITOR_QUERY_STRING_PARAM}=true`);
+    } else {
+      if (!(options == null ? void 0 : options.playgroundPath)) {
+        return new Response("No playground path is configured", { status: 401 });
+      }
+      (0, import_headers2.draftMode)().enable();
+      (0, import_navigation.redirect)(`${options.playgroundPath}?id=${id}&${import_canvas4.IN_CONTEXT_EDITOR_QUERY_STRING_PARAM}=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
+var import_cache = require("next/cache");
+
+// src/handler/helpers.ts
+var import_canvas_next_rsc_shared3 = require("@uniformdev/canvas-next-rsc-shared");
+var import_edge_config = require("@vercel/edge-config");
+var import_svix = require("svix");
+
+// src/clients/projectMapClient.ts
+var import_project_map = require("@uniformdev/project-map");
+var getProjectMapClient = (options) => {
+  const manifestClient = new import_project_map.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 import_svix.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 = (0, import_canvas_next_rsc_shared3.getServerConfig)();
+  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 } = (0, import_edge_config.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
+var import_webhooks = require("@uniformdev/webhooks");
+var handleCompositionChanged = async (body) => {
+  const parsed = import_webhooks.CompositionChangedDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  return processCompositionChange(parsed.data.id);
+};
+
+// src/handler/messages/handleCompositionDeleted.ts
+var import_webhooks2 = require("@uniformdev/webhooks");
+var handleCompositionDeleted = async (body) => {
+  const parsed = import_webhooks2.CompositionDeletedDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  return processCompositionChange(parsed.data.id);
+};
+
+// src/handler/messages/handleCompositionPublished.ts
+var import_webhooks3 = require("@uniformdev/webhooks");
+var handleCompositionPublished = async (body) => {
+  const parsed = import_webhooks3.CompositionPublishedDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  return processCompositionChange(parsed.data.id);
+};
+
+// src/handler/messages/handleManifestPublished.ts
+var import_webhooks4 = require("@uniformdev/webhooks");
+var handleManifestPublished = async (body) => {
+  const parsed = import_webhooks4.ManifestPublishedDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  return {
+    tags: ["manifest"]
+  };
+};
+
+// src/handler/messages/handleProjectMapNodeDelete.ts
+var import_canvas_next_rsc_shared4 = require("@uniformdev/canvas-next-rsc-shared");
+var import_webhooks5 = require("@uniformdev/webhooks");
+var handleProjectMapNodeDelete = async (body) => {
+  var _a;
+  const parsed = import_webhooks5.ProjectMapNodeDeleteDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  const tags = [];
+  tags.push(...buildProjectMapNodePaths(parsed.data.path));
+  const config = (0, import_canvas_next_rsc_shared4.getServerConfig)();
+  if ((_a = config.experimental) == null ? void 0 : _a.edgeCompositions) {
+    await processEdgeConfigChange({
+      source_url: parsed.data.path
+    });
+  }
+  return {
+    tags
+  };
+};
+
+// src/handler/messages/handleProjectMapNodeInsert.ts
+var import_canvas_next_rsc_shared5 = require("@uniformdev/canvas-next-rsc-shared");
+var import_webhooks6 = require("@uniformdev/webhooks");
+var handleProjectMapNodeInsert = async (body) => {
+  var _a;
+  const parsed = import_webhooks6.ProjectMapNodeInsertDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  const tags = [];
+  tags.push(...buildProjectMapNodePaths(parsed.data.path));
+  const config = (0, import_canvas_next_rsc_shared5.getServerConfig)();
+  if ((_a = config.experimental) == null ? void 0 : _a.edgeCompositions) {
+    await processEdgeConfigChange({
+      source_url: parsed.data.path
+    });
+  }
+  return {
+    tags
+  };
+};
+
+// src/handler/messages/handleProjectMapNodeUpdate.ts
+var import_canvas_next_rsc_shared6 = require("@uniformdev/canvas-next-rsc-shared");
+var import_webhooks7 = require("@uniformdev/webhooks");
+var handleProjectMapNodeUpdate = async (body) => {
+  var _a;
+  const parsed = import_webhooks7.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 = (0, import_canvas_next_rsc_shared6.getServerConfig)();
+  if ((_a = config.experimental) == null ? void 0 : _a.edgeCompositions) {
+    await processEdgeConfigChange({
+      source_url: parsed.data.path
+    });
+  }
+  return {
+    tags
+  };
+};
+
+// src/handler/messages/handleRedirectDelete.ts
+var import_canvas_next_rsc_shared7 = require("@uniformdev/canvas-next-rsc-shared");
+var import_webhooks8 = require("@uniformdev/webhooks");
+var handleRedirectDelete = async (body) => {
+  var _a;
+  const parsed = import_webhooks8.RedirectDeleteDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  const config = (0, import_canvas_next_rsc_shared7.getServerConfig)();
+  if ((_a = config.experimental) == null ? void 0 : _a.edgeRedirects) {
+    await processEdgeConfigChange(parsed.data);
+  }
+  return processRedirectChange(parsed.data.source_url);
+};
+
+// src/handler/messages/handleRedirectInsert.ts
+var import_canvas_next_rsc_shared8 = require("@uniformdev/canvas-next-rsc-shared");
+var import_webhooks9 = require("@uniformdev/webhooks");
+var handleRedirectInsert = async (body) => {
+  var _a;
+  const parsed = import_webhooks9.RedirectInsertDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  const config = (0, import_canvas_next_rsc_shared8.getServerConfig)();
+  if ((_a = config.experimental) == null ? void 0 : _a.edgeRedirects) {
+    await processEdgeConfigChange(parsed.data);
+  }
+  return processRedirectChange(parsed.data.source_url);
+};
+
+// src/handler/messages/handleRedirectUpdate.ts
+var import_canvas_next_rsc_shared9 = require("@uniformdev/canvas-next-rsc-shared");
+var import_webhooks10 = require("@uniformdev/webhooks");
+var handleRedirectUpdate = async (body) => {
+  var _a;
+  const parsed = import_webhooks10.RedirectUpdateDefinition.schema.safeParse(body);
+  if (!parsed.success) {
+    return void 0;
+  }
+  const config = (0, import_canvas_next_rsc_shared9.getServerConfig)();
+  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];
+      (0, import_cache.revalidateTag)(tag);
+    }
+  }
+  return new Response(
+    JSON.stringify({
+      handled: typeof tags !== "undefined",
+      tags
+    })
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPreviewGETRouteHandler,
+  createPreviewOPTIONSRouteHandler,
+  createPreviewPOSTRouteHandler
+});