@nitrogenbuilder/connector-payload 0.1.43 → 0.1.44

package/dist/collection-registry.d.ts

@@ -3,8 +3,14 @@
  *
  * The plugin registers collections at init time via `registerCollection()`.
  */
+type RegisteredCollection = {
+    collectionSlug: string;
+    routePattern?: string;
+};
 export declare function registerCollection(alias: string, collectionSlug: string, routePattern?: string): void;
 export declare function resolveCollection(postType: string): string;
 export declare function resolveCollectionRoutePattern(postType: string): string | undefined;
+export declare function getRegisteredCollections(): RegisteredCollection[];
 export declare function buildRelativePermalink(postType: string, slug: string): string;
 export declare function buildPermalink(postType: string, slug: string, frontendUrl?: string): string;
+export {};

package/dist/collection-registry.js

@@ -33,6 +33,16 @@ export function resolveCollection(postType) {
 export function resolveCollectionRoutePattern(postType) {
     return registeredCollections.get(postType)?.routePattern;
 }
+export function getRegisteredCollections() {
+    const collectionsBySlug = new Map();
+    for (const collection of registeredCollections.values()) {
+        const existing = collectionsBySlug.get(collection.collectionSlug);
+        if (!existing || (!existing.routePattern && collection.routePattern)) {
+            collectionsBySlug.set(collection.collectionSlug, collection);
+        }
+    }
+    return Array.from(collectionsBySlug.values());
+}
 export function buildRelativePermalink(postType, slug) {
     return buildRelativePath(resolveCollectionRoutePattern(postType), slug);
 }

package/dist/endpoints/collection-endpoints.js

@@ -1,4 +1,4 @@
-import { getNitrogenSettings, buildDynamicData, buildPageResponse, buildListItemResponse, getTemplateForType, requireAuth, } from './helpers.js';
+import { getNitrogenSettings, buildDynamicData, buildResolvedPageResponse, buildResolvedListItemResponse, getTemplateForType, requireAuth, } from './helpers.js';
 /**
  * Creates a complete set of CRUD endpoints for a given Payload collection.
  *
@@ -28,7 +28,7 @@ export function createCollectionEndpoints(collectionSlug, endpointPrefix) {
                     limit: 0,
                     depth: 1,
                 });
-                const items = result.docs.map((doc) => buildListItemResponse(doc, settings, collectionSlug));
+                const items = await Promise.all(result.docs.map((doc) => buildResolvedListItemResponse(payload, doc, settings, collectionSlug)));
                 return Response.json(items);
             },
         },
@@ -75,8 +75,9 @@ export function createCollectionEndpoints(collectionSlug, endpointPrefix) {
                         getTemplateForType(payload, collectionSlug),
                     ]);
                     const dynamicData = buildDynamicData(doc, settings);
+                    const response = await buildResolvedPageResponse(payload, doc, settings, dynamicData, collectionSlug);
                     return Response.json({
-                        ...buildPageResponse(doc, settings, dynamicData, collectionSlug),
+                        ...response,
                         template: pageTemplate,
                         headerTemplate,
                         footerTemplate,
@@ -190,8 +191,9 @@ export function createCollectionEndpoints(collectionSlug, endpointPrefix) {
                 }
                 const doc = result.docs[0];
                 const dynamicData = buildDynamicData(doc, settings);
+                const response = await buildResolvedPageResponse(payload, doc, settings, dynamicData, collectionSlug);
                 return Response.json({
-                    ...buildPageResponse(doc, settings, dynamicData, collectionSlug),
+                    ...response,
                     template: pageTemplate,
                     headerTemplate,
                     footerTemplate,
@@ -217,8 +219,9 @@ export function createCollectionEndpoints(collectionSlug, endpointPrefix) {
                 }
                 const doc = result.docs[0];
                 const dynamicData = buildDynamicData(doc, settings);
+                const response = await buildResolvedPageResponse(payload, doc, settings, dynamicData, collectionSlug);
                 return Response.json({
-                    ...buildPageResponse(doc, settings, dynamicData, collectionSlug),
+                    ...response,
                     template: pageTemplate,
                     headerTemplate,
                     footerTemplate,

package/dist/endpoints/ctrlLinkResolver.d.ts

@@ -0,0 +1,3 @@
+import type { Payload } from 'payload';
+import type { NitrogenSettingsGlobal } from '../types.js';
+export declare function resolveCtrlLinksInNitrogenData<T>(payload: Payload, value: T, settings: NitrogenSettingsGlobal): Promise<T>;

package/dist/endpoints/ctrlLinkResolver.js

@@ -0,0 +1,228 @@
+import { buildRelativePermalink, getRegisteredCollections, } from '../collection-registry.js';
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function getString(value) {
+    return typeof value === 'string' ? value : '';
+}
+function getId(value) {
+    if (typeof value === 'string' || typeof value === 'number')
+        return value;
+    return null;
+}
+function cloneJson(value) {
+    if (value === undefined)
+        return value;
+    return JSON.parse(JSON.stringify(value));
+}
+function normalizeRelativePath(value) {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed === '/home')
+        return '/';
+    try {
+        const parsed = new URL(trimmed);
+        return normalizeRelativePath(`${parsed.pathname}${parsed.search}${parsed.hash}`);
+    }
+    catch {
+        // Treat as already relative.
+    }
+    const [path = '', suffix = ''] = trimmed.split(/([?#].*)/, 2);
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+    const withoutTrailingSlash = normalizedPath.length > 1 ? normalizedPath.replace(/\/+$/, '') : normalizedPath;
+    return `${withoutTrailingSlash}${suffix}`;
+}
+function getPathname(value) {
+    const normalized = normalizeRelativePath(value);
+    return normalized.split(/[?#]/)[0] || '/';
+}
+function matchRoutePattern(pathname, routePattern) {
+    if (!routePattern)
+        return 1;
+    const pattern = getPathname(routePattern);
+    const placeholderMatch = pattern.match(/\[(?:\.\.\.)?slug\]/);
+    if (placeholderMatch) {
+        const base = pattern.slice(0, placeholderMatch.index).replace(/\/+$/, '');
+        if (!base) {
+            return pathname === '/' ? 0 : 20;
+        }
+        return pathname.startsWith(`${base}/`) ? 100 + base.length : 0;
+    }
+    if (pathname === pattern)
+        return 90 + pattern.length;
+    return pathname.startsWith(`${pattern}/`) ? 50 + pattern.length : 0;
+}
+function getCollectionCandidates(link, internalRef) {
+    const explicitCollection = getString(internalRef.collection) ||
+        getString(internalRef.collectionSlug) ||
+        getString(link.collection) ||
+        getString(link.collectionSlug);
+    const savedPath = getString(internalRef.relativePermalink) ||
+        getString(link.url) ||
+        getString(internalRef.slug);
+    const pathname = getPathname(savedPath);
+    const candidates = new Map();
+    if (explicitCollection) {
+        candidates.set(explicitCollection, Number.MAX_SAFE_INTEGER);
+    }
+    for (const collection of getRegisteredCollections()) {
+        const score = matchRoutePattern(pathname, collection.routePattern);
+        if (score <= 0)
+            continue;
+        candidates.set(collection.collectionSlug, Math.max(candidates.get(collection.collectionSlug) || 0, score));
+    }
+    if (!candidates.has('pages')) {
+        candidates.set('pages', 1);
+    }
+    return Array.from(candidates.entries())
+        .sort((a, b) => b[1] - a[1])
+        .map(([collection]) => collection);
+}
+function getDocumentRelativePermalink(doc, collectionSlug) {
+    const breadcrumbs = doc.breadcrumbs;
+    const lastUrl = Array.isArray(breadcrumbs)
+        ? breadcrumbs.at(-1)?.url
+        : undefined;
+    if (typeof lastUrl === 'string' && lastUrl.trim()) {
+        return normalizeRelativePath(lastUrl);
+    }
+    return buildRelativePermalink(collectionSlug, String(doc.slug || ''));
+}
+function getDocumentPermalink(doc, settings, collectionSlug) {
+    const relativePermalink = getDocumentRelativePermalink(doc, collectionSlug);
+    const baseUrl = (settings.frontendUrl || '').replace(/\/$/, '');
+    return baseUrl ? `${baseUrl}${relativePermalink}` : relativePermalink;
+}
+function getPayloadBaseUrl(settings) {
+    return (process.env.NEXT_PUBLIC_PAYLOAD_API_URL ||
+        process.env.NEXT_PUBLIC_SERVER_URL ||
+        settings.nitrogenEditorUrl ||
+        settings.instanceUrl ||
+        '').replace(/\/$/, '');
+}
+function resolveMediaUrl(url, settings) {
+    if (!url || /^https?:\/\//i.test(url))
+        return url;
+    const baseUrl = getPayloadBaseUrl(settings);
+    const relativeUrl = url.startsWith('/') ? url : `/${url}`;
+    return baseUrl ? `${baseUrl}${relativeUrl}` : relativeUrl;
+}
+async function findInternalTarget(context, link, internalRef) {
+    const entryId = getId(internalRef.entryId);
+    if (entryId === null)
+        return null;
+    const candidates = getCollectionCandidates(link, internalRef);
+    for (const collection of candidates) {
+        try {
+            const doc = (await context.payload.findByID({
+                collection: collection,
+                id: entryId,
+                depth: 1,
+                disableErrors: true,
+            }));
+            if (!doc)
+                continue;
+            return {
+                slug: String(doc.slug || internalRef.slug || ''),
+                relativePermalink: getDocumentRelativePermalink(doc, collection),
+                url: getDocumentPermalink(doc, context.settings, collection),
+            };
+        }
+        catch {
+            // Try the next candidate collection.
+        }
+    }
+    return null;
+}
+async function resolveInternalLink(context, link, internalRef) {
+    const entryId = getId(internalRef.entryId);
+    if (entryId === null)
+        return null;
+    const key = [
+        entryId,
+        getString(internalRef.relativePermalink),
+        getString(link.url),
+        getString(internalRef.collection),
+        getString(link.collection),
+    ].join(':');
+    if (!context.internalLinks.has(key)) {
+        context.internalLinks.set(key, findInternalTarget(context, link, internalRef));
+    }
+    return context.internalLinks.get(key);
+}
+async function findMediaTarget(context, mediaRef) {
+    const mediaId = getId(mediaRef.mediaId);
+    if (mediaId === null)
+        return null;
+    try {
+        const doc = (await context.payload.findByID({
+            collection: 'media',
+            id: mediaId,
+            depth: 0,
+            disableErrors: true,
+        }));
+        const url = doc?.url || '';
+        if (!doc || !url)
+            return null;
+        return {
+            filename: doc.filename || getString(mediaRef.filename),
+            mimeType: doc.mimeType || getString(mediaRef.mimeType),
+            url: resolveMediaUrl(url, context.settings),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveMediaLink(context, mediaRef) {
+    const mediaId = getId(mediaRef.mediaId);
+    if (mediaId === null)
+        return null;
+    const key = String(mediaId);
+    if (!context.mediaLinks.has(key)) {
+        context.mediaLinks.set(key, findMediaTarget(context, mediaRef));
+    }
+    return context.mediaLinks.get(key);
+}
+async function resolveLinkRecord(context, link) {
+    if (link.type === 'internal' && isRecord(link.internalRef)) {
+        const resolved = await resolveInternalLink(context, link, link.internalRef);
+        if (!resolved)
+            return;
+        link.url = resolved.url;
+        link.internalRef.slug = resolved.slug;
+        link.internalRef.relativePermalink = resolved.relativePermalink;
+        return;
+    }
+    if (link.type === 'media' && isRecord(link.mediaRef)) {
+        const resolved = await resolveMediaLink(context, link.mediaRef);
+        if (!resolved)
+            return;
+        link.url = resolved.url;
+        link.mediaRef.url = resolved.url;
+        link.mediaRef.filename = resolved.filename;
+        link.mediaRef.mimeType = resolved.mimeType;
+    }
+}
+async function walk(context, value) {
+    if (Array.isArray(value)) {
+        await Promise.all(value.map((item) => walk(context, item)));
+        return;
+    }
+    if (!isRecord(value))
+        return;
+    await resolveLinkRecord(context, value);
+    await Promise.all(Object.values(value).map((item) => walk(context, item)));
+}
+export async function resolveCtrlLinksInNitrogenData(payload, value, settings) {
+    if (!value)
+        return value;
+    const cloned = cloneJson(value);
+    const context = {
+        internalLinks: new Map(),
+        mediaLinks: new Map(),
+        payload,
+        settings,
+    };
+    await walk(context, cloned);
+    return cloned;
+}

package/dist/endpoints/helpers.d.ts

@@ -31,6 +31,29 @@ export declare function buildPageResponse(doc: NitrogenPageDoc | NitrogenTemplat
         wysiwygColors: {};
     };
 };
+export declare function buildResolvedPageResponse(payload: Payload, doc: NitrogenPageDoc | NitrogenTemplateDoc, settings: NitrogenSettingsGlobal, dynamicData: JsonObject, collectionSlug?: string): Promise<{
+    id: string | number;
+    token: string;
+    title: string;
+    author: string | number;
+    slug: string;
+    permalink: string;
+    relative_permalink: string;
+    content: string;
+    dynamic_data: JsonObject;
+    settings: JsonObject;
+    nitrogen_settings: {
+        variables?: Record<string, {
+            type?: string;
+            value?: string | boolean;
+        }> | Array<{
+            name: string;
+            value?: string;
+        }>;
+        urlMaps: never[];
+        wysiwygColors: {};
+    };
+}>;
 export declare function buildListItemResponse(doc: NitrogenPageDoc | NitrogenTemplateDoc, settings: NitrogenSettingsGlobal, collectionSlug?: string): {
     id: string | number;
     title: string;
@@ -51,6 +74,26 @@ export declare function buildListItemResponse(doc: NitrogenPageDoc | NitrogenTem
         wysiwygColors: {};
     };
 };
+export declare function buildResolvedListItemResponse(payload: Payload, doc: NitrogenPageDoc | NitrogenTemplateDoc, settings: NitrogenSettingsGlobal, collectionSlug?: string): Promise<{
+    id: string | number;
+    title: string;
+    slug: string;
+    permalink: string;
+    relative_permalink: string;
+    content: string;
+    settings: JsonObject;
+    nitrogen_settings: {
+        variables?: Record<string, {
+            type?: string;
+            value?: string | boolean;
+        }> | Array<{
+            name: string;
+            value?: string;
+        }>;
+        urlMaps: never[];
+        wysiwygColors: {};
+    };
+}>;
 export declare function buildMediaItemResponse(doc: MediaDoc): {
     id: string | number;
     filename: string;

package/dist/endpoints/helpers.js

@@ -1,4 +1,5 @@
 import { buildRelativePermalink } from '../collection-registry.js';
+import { resolveCtrlLinksInNitrogenData } from './ctrlLinkResolver.js';
 function normalizeRelativePath(value) {
     const trimmed = value.trim();
     if (!trimmed || trimmed === '/home')
@@ -95,6 +96,13 @@ export function buildPageResponse(doc, settings, dynamicData, collectionSlug = '
         },
     };
 }
+export async function buildResolvedPageResponse(payload, doc, settings, dynamicData, collectionSlug = 'pages') {
+    const response = buildPageResponse(doc, settings, dynamicData, collectionSlug);
+    if (doc.nitrogenData) {
+        response.content = JSON.stringify(await resolveCtrlLinksInNitrogenData(payload, doc.nitrogenData, settings));
+    }
+    return response;
+}
 export function buildListItemResponse(doc, settings, collectionSlug = 'pages') {
     const pageSettings = 'pageSettings' in doc ? doc.pageSettings : undefined;
     const templateSettings = 'templateSettings' in doc ? doc.templateSettings : undefined;
@@ -114,6 +122,13 @@ export function buildListItemResponse(doc, settings, collectionSlug = 'pages') {
         },
     };
 }
+export async function buildResolvedListItemResponse(payload, doc, settings, collectionSlug = 'pages') {
+    const response = buildListItemResponse(doc, settings, collectionSlug);
+    if (doc.nitrogenData) {
+        response.content = JSON.stringify(await resolveCtrlLinksInNitrogenData(payload, doc.nitrogenData, settings));
+    }
+    return response;
+}
 export function buildMediaItemResponse(doc) {
     const filename = doc.filename || '';
     const ext = filename.includes('.') ? `.${filename.split('.').pop()}` : '';
@@ -197,9 +212,13 @@ export async function getTemplateForType(payload, type) {
         const doc = result.docs[0];
         if (!doc)
             return null;
+        const settings = await getNitrogenSettings(payload);
+        const resolvedNitrogenData = doc.nitrogenData
+            ? await resolveCtrlLinksInNitrogenData(payload, doc.nitrogenData, settings)
+            : null;
         return {
             ID: doc.id,
-            content: doc.nitrogenData ? JSON.stringify(doc.nitrogenData) : '[]',
+            content: resolvedNitrogenData ? JSON.stringify(resolvedNitrogenData) : '[]',
         };
     }
     catch {

package/dist/endpoints/templates.js

@@ -1,4 +1,4 @@
-import { getNitrogenSettings, buildDynamicData, buildPageResponse, buildListItemResponse, getDocumentPermalink, getDocumentRelativePermalink, getTemplateForType, requireAuth, } from './helpers.js';
+import { getNitrogenSettings, buildDynamicData, buildResolvedPageResponse, buildResolvedListItemResponse, getDocumentPermalink, getDocumentRelativePermalink, getTemplateForType, requireAuth, } from './helpers.js';
 function isContentTemplateCollection(collection) {
     return !!collection && collection !== 'header' && collection !== 'footer';
 }
@@ -60,7 +60,7 @@ export const templatesEndpoints = [
                         // Collection may not exist — use template's own data
                     }
                 }
-                const response = buildPageResponse(doc, settings, dynamicData);
+                const response = await buildResolvedPageResponse(payload, doc, settings, dynamicData);
                 const previewTarget = getTemplatePreviewTarget(doc, settings, associatedCollection, associatedDoc);
                 return Response.json({
                     ...response,
@@ -99,11 +99,14 @@ export const templatesEndpoints = [
                 limit: 0,
                 depth: 1,
             });
-            const items = result.docs.map((doc) => ({
-                ...buildListItemResponse(doc, settings),
-                permalink: `${(settings.frontendUrl || '').replace(/\/$/, '')}/nitrogen-templates/${doc.slug}`,
-                relative_permalink: `/nitrogen-templates/${doc.slug}`,
-                postType: doc.associatedCollection || '',
+            const items = await Promise.all(result.docs.map(async (doc) => {
+                const response = await buildResolvedListItemResponse(payload, doc, settings);
+                return {
+                    ...response,
+                    permalink: `${(settings.frontendUrl || '').replace(/\/$/, '')}/nitrogen-templates/${doc.slug}`,
+                    relative_permalink: `/nitrogen-templates/${doc.slug}`,
+                    postType: doc.associatedCollection || '',
+                };
             }));
             return Response.json(items);
         },
@@ -147,7 +150,7 @@ export const templatesEndpoints = [
                         // Collection may not exist — use template's own data
                     }
                 }
-                const response = buildPageResponse(doc, settings, dynamicData);
+                const response = await buildResolvedPageResponse(payload, doc, settings, dynamicData);
                 const previewTarget = getTemplatePreviewTarget(doc, settings, associatedCollection, associatedDoc);
                 return Response.json({
                     ...response,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nitrogenbuilder/connector-payload",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "description": "Nitrogen page builder connector plugin for Payload CMS 3.x",
   "author": "Leonardo Dentzien <leo@torchmedia.ca>",
   "type": "module",