@uniformdev/canvas-next-rsc 20.31.1-alpha.1 → 20.31.1-alpha.185

package/dist/components/retrieveRoute.d.ts

@@ -0,0 +1,198 @@
+import { ResolvedRouteGetResponse, RouteGetResponseRedirect } from '@uniformdev/canvas';
+
+import { UniformCompositionProps } from './UniformComposition';
+export type ResolveRouteOptions = {
+  path: string;
+  state?: number;
+  searchParams:
+    | {
+        [key: string]: string | undefined;
+      }
+    | undefined;
+};
+export declare const resolveComposition: ({
+  searchParams,
+  params,
+  update,
+}: Pick<UniformCompositionProps, 'searchParams' | 'params' | 'update'>) => Promise<{
+  type: 'composition';
+  matchedRoute: string;
+  dynamicInputs?:
+    | {
+        [key: string]: string;
+      }
+    | undefined;
+  composition: {
+    type: string;
+    parameters?:
+      | {
+          [key: string]: {
+            value: unknown;
+            type: string;
+            connectedData?:
+              | {
+                  pointer: string;
+                  syntax: 'jptr';
+                }
+              | undefined;
+          };
+        }
+      | undefined;
+    variant?: string | undefined;
+    projectMapNodes?:
+      | {
+          id: string;
+          path: string;
+          projectMapId: string;
+        }[]
+      | undefined;
+    slots?:
+      | {
+          [key: string]: {
+            type: string;
+            parameters?:
+              | {
+                  [key: string]: {
+                    value: unknown;
+                    type: string;
+                    connectedData?:
+                      | {
+                          pointer: string;
+                          syntax: 'jptr';
+                        }
+                      | undefined;
+                  };
+                }
+              | undefined;
+            variant?: string | undefined;
+            slots?:
+              | {
+                  [key: string]: any[];
+                }
+              | undefined;
+            _id?: string | undefined;
+            _pattern?: string | undefined;
+            _dataResources?:
+              | {
+                  [key: string]: {
+                    type: string;
+                    isPatternParameter?: boolean | undefined;
+                    ignorePatternParameterDefault?: boolean | undefined;
+                    variables?:
+                      | {
+                          [key: string]: string;
+                        }
+                      | undefined;
+                  };
+                }
+              | undefined;
+            _patternDataResources?:
+              | {
+                  [key: string]: {
+                    type: string;
+                    isPatternParameter?: boolean | undefined;
+                    ignorePatternParameterDefault?: boolean | undefined;
+                    variables?:
+                      | {
+                          [key: string]: string;
+                        }
+                      | undefined;
+                  };
+                }
+              | undefined;
+            _patternError?: 'NOTFOUND' | 'CYCLIC' | undefined;
+            _overrides?:
+              | {
+                  [key: string]: {
+                    parameters?:
+                      | {
+                          [key: string]: {
+                            value: unknown;
+                            type: string;
+                            connectedData?:
+                              | {
+                                  pointer: string;
+                                  syntax: 'jptr';
+                                }
+                              | undefined;
+                          };
+                        }
+                      | undefined;
+                    variant?: string | undefined;
+                  };
+                }
+              | undefined;
+            _overridability?:
+              | {
+                  parameters?:
+                    | {
+                        [key: string]: 'yes' | 'no';
+                      }
+                    | undefined;
+                  variants?: boolean | undefined;
+                }
+              | undefined;
+          }[];
+        }
+      | undefined;
+    _id: string;
+    _slug?: string | null | undefined;
+    _name: string;
+    _dataResources?:
+      | {
+          [key: string]: {
+            type: string;
+            isPatternParameter?: boolean | undefined;
+            ignorePatternParameterDefault?: boolean | undefined;
+            variables?:
+              | {
+                  [key: string]: string;
+                }
+              | undefined;
+          };
+        }
+      | undefined;
+    _overrides?:
+      | {
+          [key: string]: {
+            parameters?:
+              | {
+                  [key: string]: {
+                    value: unknown;
+                    type: string;
+                    connectedData?:
+                      | {
+                          pointer: string;
+                          syntax: 'jptr';
+                        }
+                      | undefined;
+                  };
+                }
+              | undefined;
+            variant?: string | undefined;
+          };
+        }
+      | undefined;
+    _overridability?:
+      | {
+          parameters?:
+            | {
+                [key: string]: 'yes' | 'no';
+              }
+            | undefined;
+          variants?: boolean | undefined;
+        }
+      | undefined;
+  };
+  cookieValue: string | undefined;
+  path: string;
+  searchParams:
+    | {
+        [key: string]: string | undefined;
+      }
+    | undefined;
+  isCanvasEditing: boolean;
+  seenComponents: import('../models').SeenUniformComponent[];
+}>;
+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,146 @@
+import { CANVAS_DRAFT_STATE, CANVAS_EDITOR_STATE, CANVAS_PUBLISHED_STATE, } from '@uniformdev/canvas';
+import { RedirectClient } from '@uniformdev/redirect';
+import { get } from '@vercel/edge-config';
+import { cookies, headers } from 'next/headers';
+import { notFound, redirect } from 'next/navigation';
+import { getManifestFromApi } from '../client/manifestClient';
+import { getRouteClient } from '../client/routeClient';
+import { getRouteRevalidateInterval, getServerConfig } from '../config/helpers';
+import { isDevelopmentEnvironment, isDraftModeEnabled, isIncontextEditingEnabled, isOnVercelPreviewEnvironment, } from '../utils/draft';
+import { buildPathTag } from '../utils/tag';
+import { getBaseUrl } from '../utils/url';
+import { evaluateComposition } from './evaluateComposition';
+import { resolvePath } from './resolvePath';
+export const resolveComposition = async ({ searchParams, params, update, }) => {
+    // prefetch manifest immediately
+    void getManifestFromApi({
+        searchParams,
+    });
+    const draftMode = isDraftModeEnabled({ searchParams });
+    const previewEnvironment = isOnVercelPreviewEnvironment();
+    const isDevelopment = isDevelopmentEnvironment();
+    const isCanvasEditing = isIncontextEditingEnabled({
+        searchParams,
+    });
+    // resolve the path from provided params
+    const path = resolvePath({
+        params,
+    });
+    let state;
+    if (isCanvasEditing) {
+        state = CANVAS_EDITOR_STATE;
+    }
+    else {
+        state = draftMode || previewEnvironment || isDevelopment ? CANVAS_DRAFT_STATE : CANVAS_PUBLISHED_STATE;
+    }
+    // resolve the route from the path
+    const resolveResult = await retrieveRoute({
+        path,
+        state,
+        searchParams,
+    });
+    // if the route is a redirect, redirect
+    if (resolveResult.type === 'redirect') {
+        const href = resolveRedirectHref(resolveResult, path);
+        redirect(href);
+    }
+    // if the route is not found, return 404
+    if (resolveResult.type === 'notFound') {
+        notFound();
+    }
+    const { compositionApiResponse, ...rest } = resolveResult;
+    // evaluate the composition
+    const { cookieValue, composition: evaluatedComposition, seenComponents, } = await evaluateComposition({
+        root: compositionApiResponse.composition,
+        params,
+        searchParams: searchParams !== null && searchParams !== void 0 ? searchParams : {},
+        dynamicInputs: rest.dynamicInputs,
+        headers: headers(),
+        cookies: cookies()
+            .getAll()
+            .reduce((acc, cookie) => {
+            acc[cookie.name] = cookie.value;
+            return acc;
+        }, {}),
+        update,
+    });
+    return {
+        composition: evaluatedComposition,
+        cookieValue,
+        path,
+        searchParams,
+        isCanvasEditing,
+        seenComponents,
+        ...rest,
+    };
+};
+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;
+    }
+    // fall back to draft if requesting editor state
+    if (result.type === 'notFound' && data.state === CANVAS_EDITOR_STATE) {
+        return retrieveRoute({
+            ...data,
+            state: CANVAS_DRAFT_STATE,
+        });
+    }
+    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;
+    const config = getServerConfig();
+    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) => {
+    var _a;
+    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 || data.state === CANVAS_EDITOR_STATE,
+        withContentSourceMap: isOnVercelPreviewEnvironment() && ((_a = getServerConfig().experimental) === null || _a === void 0 ? void 0 : _a.vercelVisualEditing),
+    });
+    return routeResult;
+};

package/dist/components/types.d.ts

@@ -0,0 +1,15 @@
+import { RichTextNode } from '@uniformdev/richtext';
+import React, { PropsWithChildren } from 'react';
+export type RichTextComponentProps<TNode extends RichTextNode = RichTextNode> = {
+  node: TNode;
+};
+export type RichTextRendererComponent<TNode extends RichTextNode = RichTextNode> = React.ComponentType<
+  PropsWithChildren<RichTextComponentProps<TNode>>
+>;
+/**
+ * Function that maps a Rich Text node instance to its React component to render it.
+ * The resolver would commonly inspect the `type` of the component to decide.
+ */
+export type RenderRichTextComponentResolver = (
+  node: RichTextNode
+) => RichTextRendererComponent | null | undefined;

package/dist/components/types.js

@@ -0,0 +1 @@
+export {};

package/dist/config/helpers.d.ts

@@ -0,0 +1,23 @@
+import { UniformServerConfig } from './models';
+export declare const getCanvasRevalidateInterval: (options: {
+  searchParams:
+    | {
+        [key: string]: string | undefined;
+      }
+    | undefined;
+}) => number | undefined;
+export declare const getManifestRevalidateInterval: (options: {
+  searchParams:
+    | {
+        [key: string]: string | undefined;
+      }
+    | undefined;
+}) => number | undefined;
+export declare const getRouteRevalidateInterval: (options: {
+  searchParams:
+    | {
+        [key: string]: string | undefined;
+      }
+    | undefined;
+}) => number | undefined;
+export declare const getServerConfig: () => UniformServerConfig;

package/dist/config/helpers.js

@@ -0,0 +1,34 @@
+import { isDraftModeEnabled, isOnVercelPreviewEnvironment } from '../utils/draft';
+export const getCanvasRevalidateInterval = (options) => {
+    if (isDraftModeEnabled({ searchParams: options.searchParams }) || isOnVercelPreviewEnvironment()) {
+        return -1;
+    }
+    const config = getServerConfig();
+    return 'canvasRevalidateInterval' in config ? config.canvasRevalidateInterval : undefined;
+};
+export const getManifestRevalidateInterval = (options) => {
+    if (isDraftModeEnabled({ searchParams: options.searchParams }) || isOnVercelPreviewEnvironment()) {
+        return -1;
+    }
+    const config = getServerConfig();
+    return 'manifestRevalidateInterval' in config ? config.manifestRevalidateInterval : undefined;
+};
+export const getRouteRevalidateInterval = (options) => {
+    if (isDraftModeEnabled({ searchParams: options.searchParams }) || isOnVercelPreviewEnvironment()) {
+        return -1;
+    }
+    const config = getServerConfig();
+    return 'routeRevalidateInterval' in config ? config.routeRevalidateInterval : undefined;
+};
+export const getServerConfig = () => {
+    let serverConfig;
+    try {
+        serverConfig = require('uniform.server.config.js');
+    }
+    catch (e) {
+        serverConfig = {
+            defaultConsent: false,
+        };
+    }
+    return serverConfig;
+};

package/dist/config/models.d.ts

@@ -0,0 +1,51 @@
+export type UniformServerConfig = {
+  /**
+   * Sets the default value of storage consent for new unknown visitors.
+   *
+   * @default false
+   */
+  defaultConsent?: boolean;
+  /**
+   * Interval to revalidate the manifest at.
+   *
+   * @default 60
+   */
+  manifestRevalidateInterval?: number;
+  /**
+   * Interval to revalidate route data at.
+   *
+   * @default 10
+   */
+  routeRevalidateInterval?: number;
+  /**
+   * Interval to revalidate canvas data at.
+   *
+   * @default 10
+   */
+  canvasRevalidateInterval?: number;
+  /**
+   * 😅
+   */
+  experimental?: {
+    /**
+     * Enables edge cache of redirects.
+     *
+     * @default false
+     */
+    edgeRedirects?: boolean;
+    /**
+     * Enables edge cache of compositions.
+     *
+     * @default false
+     */
+    edgeCompositions?: boolean;
+    /**
+     * Dynamic tokens names that should be used for localization.
+     */
+    localeDynamicInputs?: string[];
+    /**
+     * Enables visual editing mode.
+     */
+    vercelVisualEditing?: boolean;
+  };
+};

package/dist/config/models.js

@@ -0,0 +1 @@
+export {};

package/dist/config/uniform.server.config.d.ts

@@ -0,0 +1,3 @@
+import { UniformServerConfig } from './models';
+declare const config: UniformServerConfig;
+export default config;

package/dist/config/uniform.server.config.js

@@ -0,0 +1,4 @@
+/** @type {import('@uniformdev/canvas-next-rsc/config').UniformServerConfig} */
+module.exports = {
+  defaultConsent: true,
+};

package/dist/cookie/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Sets the Uniform cookie with the provided value.
+ */
+export declare const setUniformCookie: (value: string) => void;
+/**
+ * Determine if the Uniform cookie is present.
+ */
+export declare const hasUniformCookie: () => boolean;
+/**
+ * Gets the Uniform cookie value.
+ */
+export declare const removeUniformCookie: () => void;

package/dist/cookie/index.js

@@ -0,0 +1,21 @@
+import { UNIFORM_DEFAULT_COOKIE_NAME } from '@uniformdev/context';
+import Cookies from 'js-cookie';
+/**
+ * Sets the Uniform cookie with the provided value.
+ */
+export const setUniformCookie = (value) => {
+    Cookies.set(UNIFORM_DEFAULT_COOKIE_NAME, value);
+};
+/**
+ * Determine if the Uniform cookie is present.
+ */
+export const hasUniformCookie = () => {
+    const cookie = Cookies.get(UNIFORM_DEFAULT_COOKIE_NAME);
+    return Boolean(cookie);
+};
+/**
+ * Gets the Uniform cookie value.
+ */
+export const removeUniformCookie = () => {
+    Cookies.remove(UNIFORM_DEFAULT_COOKIE_NAME);
+};

package/dist/handler/createPreviewGETRouteHandler.d.ts

@@ -0,0 +1 @@
+export declare const createPreviewGETRouteHandler: () => (request: Request) => Promise<Response>;

package/dist/handler/createPreviewGETRouteHandler.js

@@ -0,0 +1,43 @@
+import { CANVAS_DRAFT_STATE, IN_CONTEXT_EDITOR_QUERY_STRING_PARAM } from '@uniformdev/canvas';
+import { draftMode } from 'next/headers';
+import { redirect } from 'next/navigation';
+import { resolveRedirectHref, retrieveRoute } from '../components/retrieveRoute';
+export const createPreviewGETRouteHandler = () => {
+    return async (request) => {
+        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');
+        if (secret !== process.env.UNIFORM_PREVIEW_SECRET) {
+            return new Response('Invalid preview secret', { status: 401 });
+        }
+        if (!path) {
+            return new Response('Path not provided', { status: 401 });
+        }
+        const resolveResult = await retrieveRoute({
+            path,
+            state: CANVAS_DRAFT_STATE,
+            searchParams: {
+                // about to be in draft mode so pretend for now.
+                [IN_CONTEXT_EDITOR_QUERY_STRING_PARAM]: 'true',
+            },
+        });
+        draftMode().enable();
+        if (resolveResult.type === 'redirect') {
+            const href = resolveRedirectHref(resolveResult, path);
+            if (resolveResult.redirect.targetProjectMapNodeId) {
+                // do we need this query string param still with draft mode cookie?
+                redirect(`${href}?${IN_CONTEXT_EDITOR_QUERY_STRING_PARAM}=true`);
+            }
+            else {
+                redirect(href);
+            }
+        }
+        if (resolveResult.type === 'notFound') {
+            return new Response('Invalid path', { status: 401 });
+        }
+        redirect(`${path}?${IN_CONTEXT_EDITOR_QUERY_STRING_PARAM}=true`);
+    };
+};

package/dist/handler/createPreviewPOSTRouteHandler.d.ts

@@ -0,0 +1 @@
+export declare const createPreviewPOSTRouteHandler: () => (request: Request) => Promise<Response>;

package/dist/handler/createPreviewPOSTRouteHandler.js

@@ -0,0 +1,88 @@
+import { CANVAS_DRAFT_STATE, generateHash } from '@uniformdev/canvas';
+import { revalidateTag } from 'next/cache';
+import { NextResponse } from 'next/server';
+import { getCanvasClient } from '../client/canvasClient';
+import { diff } from '../utils/diff';
+import { isSvixMessage } from './helpers';
+import { handleCompositionChanged } from './messages/handleCompositionChanged';
+import { handleCompositionDeleted } from './messages/handleCompositionDeleted';
+import { handleCompositionPublished } from './messages/handleCompositionPublished';
+import { handleManifestPublished } from './messages/handleManifestPublished';
+import { handleProjectMapNodeDelete } from './messages/handleProjectMapNodeDelete';
+import { handleProjectMapNodeInsert } from './messages/handleProjectMapNodeInsert';
+import { handleProjectMapNodeUpdate } from './messages/handleProjectMapNodeUpdate';
+import { handleRedirectDelete } from './messages/handleRedirectDelete';
+import { handleRedirectInsert } from './messages/handleRedirectInsert';
+import { handleRedirectUpdate } from './messages/handleRedirectUpdate';
+export const 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);
+        }
+        if (!process.env.UNIFORM_PREVIEW_SECRET) {
+            return new Response('No preview secret is configured', { status: 401 });
+        }
+        const message = (await request.json());
+        if (!(message === null || message === void 0 ? void 0 : message.composition) || !(message === null || message === void 0 ? void 0 : message.hash)) {
+            return new Response('Invalid message', { status: 401 });
+        }
+        const { composition, hash } = message;
+        const calculatedHash = generateHash({
+            composition,
+            secret: process.env.UNIFORM_PREVIEW_SECRET,
+        });
+        if (hash !== calculatedHash) {
+            return new Response('Invalid hash', { status: 401 });
+        }
+        const canvasClient = await getCanvasClient();
+        const { composition: existingComposition } = await canvasClient.getCompositionById({
+            compositionId: composition._id,
+            state: CANVAS_DRAFT_STATE,
+            withComponentIDs: true,
+        });
+        const compositionDiff = diff(existingComposition, composition);
+        return NextResponse.json({
+            composition,
+            existingComposition,
+            diff: compositionDiff,
+        });
+    };
+};
+const handleSvixMessage = async (request) => {
+    const handlers = [
+        handleProjectMapNodeUpdate,
+        handleProjectMapNodeInsert,
+        handleProjectMapNodeDelete,
+        handleCompositionDeleted,
+        handleCompositionChanged,
+        handleCompositionPublished,
+        handleRedirectInsert,
+        handleRedirectUpdate,
+        handleRedirectDelete,
+        handleManifestPublished,
+    ];
+    let tags = undefined;
+    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 || tags === void 0 ? 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,
+    }));
+};

package/dist/handler/createUniformRouteHandler.d.ts

@@ -0,0 +1,4 @@
+export declare const createUniformRouteHandler: () => {
+  GET: (request: Request) => Promise<Response>;
+  POST: (request: Request) => Promise<Response>;
+};

package/dist/handler/createUniformRouteHandler.js

@@ -0,0 +1,10 @@
+import { createPreviewGETRouteHandler } from './createPreviewGETRouteHandler';
+import { createPreviewPOSTRouteHandler } from './createPreviewPOSTRouteHandler';
+export const createUniformRouteHandler = () => {
+    const GET = createPreviewGETRouteHandler();
+    const POST = createPreviewPOSTRouteHandler();
+    return {
+        GET,
+        POST,
+    };
+};