@uniformdev/canvas-next-rsc 19.30.1-alpha.0 → 19.33.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

@@ -33,5 +33,11 @@ export type UniformServerConfig = {
          * @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.js

@@ -1,6 +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'];
@@ -39,9 +41,15 @@ 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,
     };
@@ -64,6 +72,7 @@ export const processRedirectChange = async (sourceUrl) => {
     };
 };
 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');
@@ -76,12 +85,24 @@ export const processEdgeConfigChange = async ({ source_url }) => {
         path: source_url,
     });
     let valueToStore = undefined;
-    if (route.type === 'redirect') {
+    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 response = await fetch(`https://api.vercel.com/v1/edge-config/${process.env.UNIFORM_EDGE_CONFIG_ID}/items?teamId=${process.env.UNIFORM_EDGE_CONFIG_TEAM_ID}`, {
+    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',

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/utils/tag.js

@@ -1,3 +1,4 @@
 export const buildPathTag = (path) => {
-    return `path:${path}`;
+    const actualPath = path.startsWith('/') ? path : `/${path}`;
+    return `path:${actualPath}`;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniformdev/canvas-next-rsc",
-  "version": "19.30.1-alpha.0+fa7b5018a",
+  "version": "19.33.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.0+fa7b5018a",
-    "@uniformdev/canvas-react": "^19.30.1-alpha.0+fa7b5018a",
-    "@uniformdev/context": "^19.30.1-alpha.0+fa7b5018a",
-    "@uniformdev/project-map": "^19.30.1-alpha.0+fa7b5018a",
-    "@uniformdev/redirect": "^19.30.1-alpha.0+fa7b5018a",
-    "@uniformdev/webhooks": "^19.30.1-alpha.0+fa7b5018a",
+    "@uniformdev/canvas": "^19.33.0",
+    "@uniformdev/canvas-react": "^19.33.0",
+    "@uniformdev/context": "^19.33.0",
+    "@uniformdev/project-map": "^19.33.0",
+    "@uniformdev/redirect": "^19.33.0",
+    "@uniformdev/webhooks": "^19.33.0",
     "@vercel/edge-config": "^0.1.5",
     "dequal": "^2.0.3",
     "js-cookie": "^3.0.5",
@@ -75,5 +75,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "fa7b5018a6723a15f1932d306a1e674e4a8baf5d"
+  "gitHead": "a26cf289e832737b2cf4c9b6d767640b627a6368"
 }

package/dist/components/resolveRoute.d.ts

@@ -1,25 +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>;

package/dist/components/resolveRoute.js

@@ -1,106 +0,0 @@
-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 resolveRoute = async (data) => {
-    const apiPromise = resolveRouteByRouteApi(data);
-    const edgeConfigPromise = resolveRouteByEdgeConfig(data);
-    const first = await Promise.race([apiPromise, edgeConfigPromise]);
-    let result;
-    if (first === null || first === void 0 ? void 0 : first.value) {
-        result = first.value;
-    }
-    else if ((first === null || first === void 0 ? void 0 : first.source) === 'edgeConfig') {
-        const apiResult = await apiPromise;
-        result = apiResult === null || apiResult === void 0 ? void 0 : apiResult.value;
-    }
-    else if ((first === null || first === void 0 ? void 0 : first.source) === 'routeApi') {
-        const edgeConfigResult = await edgeConfigPromise;
-        result = edgeConfigResult === null || edgeConfigResult === void 0 ? void 0 : edgeConfigResult.value;
-    }
-    if (result) {
-        const processed = processRouteResponse(data.path, result);
-        if (processed) {
-            return processed;
-        }
-    }
-    return {
-        type: 'notFound',
-    };
-};
-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 soucrcePathKey = buildPathTag(data.path);
-    const key = soucrcePathKey.replace(/\W+/g, '');
-    const edgeConfig = await get(key);
-    if (!edgeConfig) {
-        return undefined;
-    }
-    return {
-        source: 'edgeConfig',
-        value: 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 {
-        source: 'routeApi',
-        value: routeResult,
-    };
-};
-const processRouteResponse = (path, routeResult) => {
-    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()}${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,
-            },
-        };
-    }
-    else {
-        return {
-            type: 'notFound',
-        };
-    }
-};