@uniformdev/canvas-next-rsc 19.30.1-alpha.5 → 19.34.0

package/dist/components/UniformComposition.js

@@ -6,7 +6,7 @@ import { getManifestFromApi } from '../client/manifestClient';
 import { isDraftModeEnabled, isOnVercelPreviewEnvironment } from '../utils/draft';
 import { evaluateComposition } from './evaluateComposition';
 import { resolvePath } from './resolvePath';
-import { resolveRoute } from './resolveRoute';
+import { resolveRedirectHref, retrieveRoute } from './retrieveRoute';
 import { UniformComponent } from './UniformComponent';
 import { UniformProvider } from './UniformContext';
 import { UniformScript } from './UniformScript';
@@ -31,14 +31,15 @@ const UniformCompositionInner = async ({ params, searchParams, children }) => {
         params,
     });
     // resolve the route from the path
-    const resolveResult = await resolveRoute({
+    const resolveResult = await retrieveRoute({
         path,
         state: draftMode || previewEnvironment ? CANVAS_DRAFT_STATE : CANVAS_PUBLISHED_STATE,
         searchParams,
     });
     // if the route is a redirect, redirect
     if (resolveResult.type === 'redirect') {
-        redirect(resolveResult.redirect.href);
+        const href = resolveRedirectHref(resolveResult, path);
+        redirect(href);
     }
     // if the route is not found, return 404
     if (resolveResult.type === 'notFound') {
@@ -46,7 +47,7 @@ const UniformCompositionInner = async ({ params, searchParams, children }) => {
     }
     // evaluate the composition
     const { cookieValue, composition: evaluatedComposition, seenComponents, } = await evaluateComposition({
-        root: resolveResult.composition,
+        root: resolveResult.compositionApiResponse.composition,
         params,
         searchParams: searchParams !== null && searchParams !== void 0 ? searchParams : {},
     });

package/dist/components/retrieveRoute.d.ts

@@ -0,0 +1,10 @@
+import { ResolvedRouteGetResponse, RouteGetResponseRedirect } from '@uniformdev/canvas';
+export type ResolveRouteOptions = {
+    path: string;
+    state?: number;
+    searchParams: {
+        [key: string]: string | undefined;
+    } | undefined;
+};
+export declare const retrieveRoute: (data: ResolveRouteOptions) => Promise<ResolvedRouteGetResponse>;
+export declare const resolveRedirectHref: (resolveResult: RouteGetResponseRedirect, path: string) => string;

package/dist/components/retrieveRoute.js

@@ -0,0 +1,70 @@
+import { CANVAS_DRAFT_STATE } from '@uniformdev/canvas';
+import { RedirectClient } from '@uniformdev/redirect';
+import { get } from '@vercel/edge-config';
+import { getRouteClient } from '../client/routeClient';
+import { getRouteRevalidateInterval } from '../config/helpers';
+import config from '../config/uniform.server.config';
+import { isOnVercelPreviewEnvironment } from '../utils/draft';
+import { buildPathTag } from '../utils/tag';
+import { getBaseUrl } from '../utils/url';
+export const retrieveRoute = async (data) => {
+    void resolveRouteByEdgeConfig(data);
+    void resolveRouteByRouteApi(data);
+    const edgeConfigValue = await resolveRouteByEdgeConfig(data);
+    let result;
+    if (edgeConfigValue) {
+        result = edgeConfigValue;
+    }
+    else {
+        const routeApiValue = await resolveRouteByRouteApi(data);
+        result = routeApiValue;
+    }
+    return result;
+};
+export const resolveRedirectHref = (resolveResult, path) => {
+    let href;
+    if (resolveResult.redirect.targetProjectMapNodeId) {
+        const requestUrl = `${getBaseUrl()}${path}`;
+        const expandedUrl = RedirectClient.getTargetVariableExpandedUrl(requestUrl, resolveResult.redirect);
+        const url = new URL(expandedUrl);
+        href = url.pathname;
+    }
+    else {
+        href = resolveResult.redirect.targetUrl;
+    }
+    return href;
+};
+const resolveRouteByEdgeConfig = async (data) => {
+    var _a;
+    if (!((_a = config.experimental) === null || _a === void 0 ? void 0 : _a.edgeRedirects) || !process.env.EDGE_CONFIG) {
+        return undefined;
+    }
+    const sourcePathKey = buildPathTag(data.path);
+    const key = sourcePathKey.replace(/\W+/g, '');
+    let edgeConfig;
+    try {
+        edgeConfig = await get(key);
+    }
+    catch (e) {
+        // eslint-disable-next-line no-console
+        console.warn('Failed to retrieve edge config', e);
+    }
+    if (!edgeConfig) {
+        return undefined;
+    }
+    return edgeConfig;
+};
+const resolveRouteByRouteApi = async (data) => {
+    const routeClient = getRouteClient({
+        revalidate: getRouteRevalidateInterval({
+            searchParams: data.searchParams,
+        }),
+    });
+    const routeResult = await routeClient.getRoute({
+        path: data.path,
+        state: data.state,
+        withComponentIDs: data.state === CANVAS_DRAFT_STATE,
+        withContentSourceMap: isOnVercelPreviewEnvironment(),
+    });
+    return routeResult;
+};

package/dist/config/models.d.ts

@@ -23,4 +23,21 @@ export type UniformServerConfig = {
      * @default 10
      */
     canvasRevalidateInterval?: number;
+    /**
+     * 😅
+     */
+    experimental?: {
+        /**
+         * Enables edge cache of redirects.
+         *
+         * @default false
+         */
+        edgeRedirects?: boolean;
+        /**
+         * Enables edge cache of compositions.
+         *
+         * @default false
+         */
+        edgeCompositions?: boolean;
+    };
 };

package/dist/handler/createPreviewGETRouteHandler.js

@@ -1,7 +1,7 @@
 import { CANVAS_DRAFT_STATE, IN_CONTEXT_EDITOR_QUERY_STRING_PARAM } from '@uniformdev/canvas';
 import { draftMode } from 'next/headers';
 import { redirect } from 'next/navigation';
-import { resolveRoute } from '../components/resolveRoute';
+import { resolveRedirectHref, retrieveRoute } from '../components/retrieveRoute';
 export const createPreviewGETRouteHandler = () => {
     return async (request) => {
         if (!process.env.UNIFORM_PREVIEW_SECRET) {
@@ -16,7 +16,7 @@ export const createPreviewGETRouteHandler = () => {
         if (!path) {
             return new Response('Path not provided', { status: 401 });
         }
-        const resolveResult = await resolveRoute({
+        const resolveResult = await retrieveRoute({
             path,
             state: CANVAS_DRAFT_STATE,
             searchParams: {
@@ -26,13 +26,13 @@ export const createPreviewGETRouteHandler = () => {
         });
         draftMode().enable();
         if (resolveResult.type === 'redirect') {
-            const { redirect: theRedirect } = resolveResult;
-            if (theRedirect.nodeId) {
+            const href = resolveRedirectHref(resolveResult, path);
+            if (resolveResult.redirect.targetProjectMapNodeId) {
                 // do we need this query string param still with draft mode cookie?
-                redirect(`${theRedirect.href}?${IN_CONTEXT_EDITOR_QUERY_STRING_PARAM}=true`);
+                redirect(`${href}?${IN_CONTEXT_EDITOR_QUERY_STRING_PARAM}=true`);
             }
             else {
-                redirect(theRedirect.href);
+                redirect(href);
             }
         }
         if (resolveResult.type === 'notFound') {

package/dist/handler/helpers.d.ts

@@ -5,9 +5,13 @@ export declare const isSvixMessage: (request: Request) => Promise<{
 export declare const processCompositionChange: (compositionId: string) => Promise<{
     tags: string[];
 }>;
+export declare const getPathName: (url: string) => string;
 export declare const processRedirectChange: (sourceUrl: string) => Promise<{
     tags: string[];
 }>;
+export declare const processEdgeConfigChange: ({ source_url }: {
+    source_url: string;
+}) => Promise<void>;
 export type MessageHandlerResponse = {
     tags: string[];
 };

package/dist/handler/helpers.js

@@ -1,5 +1,8 @@
+import { parseConnectionString } from '@vercel/edge-config';
 import { Webhook } from 'svix';
 import { getProjectMapClient } from '../client/projectMapClient';
+import { getRouteClient } from '../client/routeClient';
+import config from '../config/uniform.server.config';
 import { buildPathTag } from '../utils/tag';
 export const isSvixMessage = async (request) => {
     const requiredHeaders = ['svix-id', 'svix-timestamp', 'svix-signature'];
@@ -38,23 +41,85 @@ export const processCompositionChange = async (compositionId) => {
         compositionId,
     });
     const tags = [];
-    nodes === null || nodes === void 0 ? void 0 : nodes.forEach((node) => {
-        tags.push(buildPathTag(node.path));
-    });
+    if (nodes) {
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+            await processEdgeConfigChange({
+                source_url: node.path,
+            });
+            tags.push(buildPathTag(node.path));
+        }
+    }
     return {
         tags,
     };
 };
-export const processRedirectChange = async (sourceUrl) => {
-    const tags = [];
+export const getPathName = (url) => {
     try {
-        const url = new URL(sourceUrl);
-        tags.push(buildPathTag(url.pathname));
+        const { pathname } = new URL(url);
+        return pathname;
     }
-    catch (e) {
-        tags.push(buildPathTag(sourceUrl));
+    catch (_a) {
+        return url;
     }
+};
+export const processRedirectChange = async (sourceUrl) => {
+    const tags = [];
+    const pathName = getPathName(sourceUrl);
+    tags.push(buildPathTag(pathName));
     return {
         tags,
     };
 };
+export const processEdgeConfigChange = async ({ source_url }) => {
+    var _a, _b;
+    if (!process.env.UNIFORM_VERCEL_EDGE_CONFIG_TOKEN) {
+        // eslint-disable-next-line no-console
+        console.warn('UNIFORM_VERCEL_EDGE_CONFIG_TOKEN is not set, skipping edge redirect upsert');
+        return;
+    }
+    const routeClient = getRouteClient({
+        revalidate: -1,
+    });
+    const route = await routeClient.getRoute({
+        path: source_url,
+    });
+    let valueToStore = undefined;
+    const shouldSaveRedirect = route.type === 'redirect' && ((_a = config.experimental) === null || _a === void 0 ? void 0 : _a.edgeRedirects);
+    const shouldSaveComposition = route.type === 'composition' && ((_b = config.experimental) === null || _b === void 0 ? 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) {
+        // eslint-disable-next-line no-console
+        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 !== void 0 ? valueToStore : null,
+                },
+            ],
+        }),
+    });
+    if (!response.ok) {
+        // eslint-disable-next-line no-console
+        console.warn(`Failed to upsert edge redirect for ${source_url}`, await response.text());
+    }
+};

package/dist/handler/messages/handleProjectMapNodeDelete.js

@@ -1,12 +1,20 @@
 import { ProjectMapNodeDeleteDefinition } from '@uniformdev/webhooks';
+import config from '../../config/uniform.server.config';
 import { buildPathTag } from '../../utils/tag';
+import { processEdgeConfigChange } from '../helpers';
 export const handleProjectMapNodeDelete = async (body) => {
+    var _a;
     const parsed = ProjectMapNodeDeleteDefinition.schema.safeParse(body);
     if (!parsed.success) {
         return undefined;
     }
     const tags = [];
     tags.push(buildPathTag(parsed.data.path));
+    if ((_a = config.experimental) === null || _a === void 0 ? void 0 : _a.edgeCompositions) {
+        await processEdgeConfigChange({
+            source_url: parsed.data.path,
+        });
+    }
     return {
         tags,
     };

package/dist/handler/messages/handleProjectMapNodeInsert.js

@@ -1,12 +1,20 @@
 import { ProjectMapNodeInsertDefinition } from '@uniformdev/webhooks';
+import config from '../../config/uniform.server.config';
 import { buildPathTag } from '../../utils/tag';
+import { processEdgeConfigChange } from '../helpers';
 export const handleProjectMapNodeInsert = async (body) => {
+    var _a;
     const parsed = ProjectMapNodeInsertDefinition.schema.safeParse(body);
     if (!parsed.success) {
         return undefined;
     }
     const tags = [];
     tags.push(buildPathTag(parsed.data.path));
+    if ((_a = config.experimental) === null || _a === void 0 ? void 0 : _a.edgeCompositions) {
+        await processEdgeConfigChange({
+            source_url: parsed.data.path,
+        });
+    }
     return {
         tags,
     };

package/dist/handler/messages/handleProjectMapNodeUpdate.js

@@ -1,6 +1,9 @@
 import { ProjectMapNodeUpdateDefinition } from '@uniformdev/webhooks';
+import config from '../../config/uniform.server.config';
 import { buildPathTag } from '../../utils/tag';
+import { processEdgeConfigChange } from '../helpers';
 export const handleProjectMapNodeUpdate = async (body) => {
+    var _a;
     const parsed = ProjectMapNodeUpdateDefinition.schema.safeParse(body);
     if (!parsed.success) {
         return undefined;
@@ -8,6 +11,11 @@ export const handleProjectMapNodeUpdate = async (body) => {
     const tags = [];
     tags.push(buildPathTag(parsed.data.path));
     tags.push(buildPathTag(parsed.data.previous_path));
+    if ((_a = config.experimental) === null || _a === void 0 ? void 0 : _a.edgeCompositions) {
+        await processEdgeConfigChange({
+            source_url: parsed.data.path,
+        });
+    }
     return {
         tags,
     };

package/dist/handler/messages/handleRedirectDelete.js

@@ -1,9 +1,14 @@
 import { RedirectDeleteDefinition } from '@uniformdev/webhooks';
-import { processRedirectChange } from '../helpers';
+import config from '../../config/uniform.server.config';
+import { processEdgeConfigChange, processRedirectChange } from '../helpers';
 export const handleRedirectDelete = async (body) => {
+    var _a;
     const parsed = RedirectDeleteDefinition.schema.safeParse(body);
     if (!parsed.success) {
         return undefined;
     }
+    if ((_a = config.experimental) === null || _a === void 0 ? void 0 : _a.edgeRedirects) {
+        await processEdgeConfigChange(parsed.data);
+    }
     return processRedirectChange(parsed.data.source_url);
 };

package/dist/handler/messages/handleRedirectInsert.js

@@ -1,9 +1,14 @@
 import { RedirectInsertDefinition } from '@uniformdev/webhooks';
-import { processRedirectChange } from '../helpers';
+import config from '../../config/uniform.server.config';
+import { processEdgeConfigChange, processRedirectChange } from '../helpers';
 export const handleRedirectInsert = async (body) => {
+    var _a;
     const parsed = RedirectInsertDefinition.schema.safeParse(body);
     if (!parsed.success) {
         return undefined;
     }
+    if ((_a = config.experimental) === null || _a === void 0 ? void 0 : _a.edgeRedirects) {
+        await processEdgeConfigChange(parsed.data);
+    }
     return processRedirectChange(parsed.data.source_url);
 };

package/dist/handler/messages/handleRedirectUpdate.js

@@ -1,9 +1,14 @@
 import { RedirectUpdateDefinition } from '@uniformdev/webhooks';
-import { processRedirectChange } from '../helpers';
+import config from '../../config/uniform.server.config';
+import { processEdgeConfigChange, processRedirectChange } from '../helpers';
 export const handleRedirectUpdate = async (body) => {
+    var _a;
     const parsed = RedirectUpdateDefinition.schema.safeParse(body);
     if (!parsed.success) {
         return undefined;
     }
+    if ((_a = config.experimental) === null || _a === void 0 ? void 0 : _a.edgeRedirects) {
+        await processEdgeConfigChange(parsed.data);
+    }
     return processRedirectChange(parsed.data.source_url);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniformdev/canvas-next-rsc",
-  "version": "19.30.1-alpha.5+2a53a5820",
+  "version": "19.34.0",
   "license": "SEE LICENSE IN LICENSE.txt",
   "scripts": {
     "dev": "pnpm build --watch",
@@ -56,12 +56,12 @@
     "typescript": "^5.0.4"
   },
   "dependencies": {
-    "@uniformdev/canvas": "^19.30.1-alpha.5+2a53a5820",
-    "@uniformdev/canvas-react": "^19.30.1-alpha.5+2a53a5820",
-    "@uniformdev/context": "^19.30.1-alpha.5+2a53a5820",
-    "@uniformdev/project-map": "^19.30.1-alpha.5+2a53a5820",
-    "@uniformdev/redirect": "^19.30.1-alpha.5+2a53a5820",
-    "@uniformdev/webhooks": "^19.30.1-alpha.5+2a53a5820",
+    "@uniformdev/canvas": "^19.34.0",
+    "@uniformdev/canvas-react": "^19.34.0",
+    "@uniformdev/context": "^19.34.0",
+    "@uniformdev/project-map": "^19.34.0",
+    "@uniformdev/redirect": "^19.34.0",
+    "@uniformdev/webhooks": "^19.34.0",
     "@vercel/edge-config": "^0.1.5",
     "dequal": "^2.0.3",
     "js-cookie": "^3.0.5",
@@ -75,5 +75,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "2a53a5820c0343ca6bc8d883ed6737717afba488"
+  "gitHead": "303a002356452a5fc312cd384a67977545a4e888"
 }

package/dist/components/resolveRoute.d.ts

@@ -1,26 +0,0 @@
-import { RootComponentInstance } from '@uniformdev/canvas';
-export type CompositionRouteResult = {
-    type: 'composition';
-    composition: RootComponentInstance;
-};
-export type RedirectRouteResult = {
-    type: 'redirect';
-    redirect: {
-        href: string;
-        statusCode: number;
-        nodeId: string | undefined;
-    };
-};
-export type NotFoundRouteResult = {
-    type: 'notFound';
-};
-export type ResolveRouteResult = CompositionRouteResult | RedirectRouteResult | NotFoundRouteResult;
-export type ResolveRouteOptions = {
-    path: string;
-    state?: number;
-    searchParams: {
-        [key: string]: string | undefined;
-    } | undefined;
-};
-export declare const resolveRoute: (data: ResolveRouteOptions) => Promise<ResolveRouteResult>;
-export declare const resolveRouteByRouteApi: (data: Pick<ResolveRouteOptions, 'path' | 'state' | 'searchParams'>) => Promise<ResolveRouteResult | undefined>;

package/dist/components/resolveRoute.js

@@ -1,59 +0,0 @@
-import { CANVAS_DRAFT_STATE } from '@uniformdev/canvas';
-import { RedirectClient } from '@uniformdev/redirect';
-import { getRouteClient } from '../client/routeClient';
-import { getRouteRevalidateInterval } from '../config/helpers';
-import { isOnVercelPreviewEnvironment } from '../utils/draft';
-import { getBaseUrl } from '../utils/url';
-export const resolveRoute = async (data) => {
-    const routeResult = await resolveRouteByRouteApi(data);
-    if (routeResult) {
-        return routeResult;
-    }
-    return {
-        type: 'notFound',
-    };
-};
-export const resolveRouteByRouteApi = async (data) => {
-    const routeClient = getRouteClient({
-        revalidate: getRouteRevalidateInterval({
-            searchParams: data.searchParams,
-        }),
-    });
-    const routeResult = await routeClient.getRoute({
-        path: data.path,
-        state: data.state,
-        withComponentIDs: data.state === CANVAS_DRAFT_STATE,
-        withContentSourceMap: isOnVercelPreviewEnvironment(),
-    });
-    if (routeResult.type === 'notFound') {
-        return {
-            type: 'notFound',
-        };
-    }
-    else if (routeResult.type === 'composition') {
-        return {
-            type: 'composition',
-            composition: routeResult.compositionApiResponse.composition,
-        };
-    }
-    else if (routeResult.type === 'redirect') {
-        let href;
-        if (routeResult.redirect.targetProjectMapNodeId) {
-            const requestUrl = `${getBaseUrl()}${data.path}`;
-            const expandedUrl = RedirectClient.getTargetVariableExpandedUrl(requestUrl, routeResult.redirect);
-            const url = new URL(expandedUrl);
-            href = url.pathname;
-        }
-        else {
-            href = routeResult.redirect.targetUrl;
-        }
-        return {
-            type: 'redirect',
-            redirect: {
-                href,
-                statusCode: routeResult.redirect.targetStatusCode,
-                nodeId: routeResult.redirect.targetProjectMapNodeId,
-            },
-        };
-    }
-};