@nitrogenbuilder/connector-payload 0.1.43 → 0.1.50

package/dist/endpoints/templateConditions.js

@@ -0,0 +1,297 @@
+/**
+ * Template Conditions — TypeScript port of the WordPress
+ * `Nitrogen\TemplateConditions` scoring engine
+ * (nitrogen-connector/includes/template-conditions.php).
+ *
+ * Resolves the best-matching nitrogen-template for a document by scoring
+ * editor-authored condition groups (OR'd groups, AND'd conditions within a
+ * group) and falling back to a legacy associatedCollection match.
+ *
+ * Everything here is pure/typed and defensive: the evaluators never throw —
+ * malformed input simply yields a non-match (false).
+ */
+import { buildDynamicData } from './helpers.js';
+import { resolveCtrlLinksInNitrogenData } from './ctrlLinkResolver.js';
+// Template types that are resolved separately (header/footer/404) and must be
+// skipped by the document template resolver.
+const RESERVED_TEMPLATE_TYPES = ['header', 'footer', 'not_found'];
+// --- Built-in condition evaluators (php:225-309) -------------------------------
+/**
+ * post_type — compare 'is'/'is_not' against context.postType.
+ * The condition value is a list (single values are coerced to a one-item list).
+ */
+function evaluatePostType(condition, context) {
+    const value = toArray(condition.value).map((v) => String(v));
+    const postType = context.postType ?? '';
+    const compare = condition.compare ?? 'is';
+    const inList = value.includes(postType);
+    return compare === 'is' ? inList : !inList;
+}
+/**
+ * post_id — compare 'is'/'is_not' against context.postId.
+ * Payload ids may be string or number, so everything is coerced to string
+ * for comparison.
+ */
+function evaluatePostId(condition, context) {
+    const value = toArray(condition.value).map((v) => String(v));
+    const postId = String(context.postId ?? '');
+    const compare = condition.compare ?? 'is';
+    const inList = value.includes(postId);
+    return compare === 'is' ? inList : !inList;
+}
+/**
+ * dynamic_data — resolve `field` (a dot-path, optionally wrapped in {{ }}) and
+ * compare it.
+ *
+ * NOTE: the exact dynamic-data path namespace is best-effort — the WP source
+ * resolved against post/acf_fields/taxonomies, whereas the Payload
+ * buildDynamicData() namespace is shaped differently (e.g. `Post.*`,
+ * `Global Variables.*`). To match editor-authored paths leniently we resolve
+ * against BOTH context.dynamic and the raw context.post (dynamic first).
+ *
+ * Compares: equals/not_equals/contains/not_contains/is_empty/is_not_empty.
+ */
+function evaluateDynamicData(condition, context) {
+    let fieldPath = condition.field ?? '';
+    const compare = condition.compare ?? 'equals';
+    const expected = condition.value ?? '';
+    if (!fieldPath) {
+        return false;
+    }
+    // Strip surrounding {{ }} wrappers, e.g. "{{Post.id}}" -> "Post.id".
+    fieldPath = fieldPath.trim().replace(/^\{\{/, '').replace(/\}\}$/, '').trim();
+    if (!fieldPath) {
+        return false;
+    }
+    // Try the dynamic-data namespace first, then fall back to the raw post.
+    let actual = resolveDotPath(context.dynamic, fieldPath);
+    if (actual === null || actual === undefined) {
+        actual = resolveDotPath(context.post, fieldPath);
+    }
+    const actualStr = Array.isArray(actual)
+        ? actual.map((v) => String(v)).join(', ')
+        : String(actual ?? '');
+    const expectedStr = String(expected ?? '');
+    switch (compare) {
+        case 'equals':
+            return actualStr === expectedStr;
+        case 'not_equals':
+            return actualStr !== expectedStr;
+        case 'contains':
+            return actualStr.includes(expectedStr);
+        case 'not_contains':
+            return !actualStr.includes(expectedStr);
+        case 'is_empty':
+            return isEmpty(actual);
+        case 'is_not_empty':
+            return !isEmpty(actual);
+        default:
+            return false;
+    }
+}
+const CONDITION_EVALUATORS = {
+    post_type: evaluatePostType,
+    post_id: evaluatePostId,
+    dynamic_data: evaluateDynamicData,
+};
+// --- Helpers -------------------------------------------------------------------
+function toArray(value) {
+    if (Array.isArray(value))
+        return value;
+    if (value === null || value === undefined)
+        return [];
+    return [value];
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+/**
+ * Mirrors PHP `empty()` closely enough for condition evaluation:
+ * null/undefined, '', '0', 0, false, and empty arrays are "empty".
+ */
+function isEmpty(value) {
+    if (value === null || value === undefined)
+        return true;
+    if (value === false || value === 0)
+        return true;
+    if (value === '' || value === '0')
+        return true;
+    if (Array.isArray(value))
+        return value.length === 0;
+    if (isRecord(value))
+        return Object.keys(value).length === 0;
+    return false;
+}
+/**
+ * Resolve a dot-notation path against a nested object/array.
+ * Returns null if any segment is missing (matching the PHP behaviour).
+ */
+function resolveDotPath(data, path) {
+    const keys = path.split('.');
+    let current = data;
+    for (const key of keys) {
+        if (isRecord(current) && Object.prototype.hasOwnProperty.call(current, key)) {
+            current = current[key];
+        }
+        else if (Array.isArray(current)) {
+            const index = Number(key);
+            if (Number.isInteger(index) && index >= 0 && index < current.length) {
+                current = current[index];
+            }
+            else {
+                return null;
+            }
+        }
+        else {
+            return null;
+        }
+    }
+    return current;
+}
+function parseConditions(templateConditions) {
+    let data = templateConditions;
+    if (typeof data === 'string') {
+        try {
+            data = JSON.parse(data);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!isRecord(data))
+        return null;
+    return data;
+}
+// --- Public API ----------------------------------------------------------------
+/**
+ * Evaluate authored conditions against a context (php:45-100).
+ *
+ * Groups are OR'd; conditions within a group are AND'd. An `exclude` flag
+ * inverts a condition's result. An unknown condition type fails the whole group.
+ *
+ * Returns the matched-condition count (score) of the first matching group, or
+ * false. If there are no conditionGroups, returns false (the caller handles the
+ * legacy fallback).
+ */
+export function evaluateConditions(templateConditions, context) {
+    const data = parseConditions(templateConditions);
+    if (!data || !Array.isArray(data.conditionGroups) || data.conditionGroups.length === 0) {
+        return false;
+    }
+    for (const group of data.conditionGroups) {
+        const conditions = group?.conditions;
+        if (!Array.isArray(conditions) || conditions.length === 0) {
+            continue;
+        }
+        let groupMatches = true;
+        let groupScore = 0;
+        for (const condition of conditions) {
+            const type = condition?.type ?? '';
+            const evaluator = CONDITION_EVALUATORS[type];
+            if (!evaluator) {
+                // Unknown condition type — treat the group as a non-match.
+                groupMatches = false;
+                break;
+            }
+            let result;
+            try {
+                result = evaluator(condition, context);
+            }
+            catch {
+                result = false;
+            }
+            // The exclude flag inverts the result.
+            if (condition?.exclude) {
+                result = !result;
+            }
+            if (!result) {
+                groupMatches = false;
+                break;
+            }
+            groupScore++;
+        }
+        if (groupMatches) {
+            return groupScore;
+        }
+    }
+    return false;
+}
+/**
+ * Build the evaluation context for a document (php:187-216, Payload-adapted).
+ */
+export function buildTemplateContext(doc, collectionSlug, settings) {
+    return {
+        post: doc,
+        postType: collectionSlug,
+        postId: String(doc.id),
+        dynamic: buildDynamicData(doc, settings),
+    };
+}
+/**
+ * Resolve the best-matching template for a document
+ * (php:140-182 resolve_template + php:106-132 evaluate_legacy).
+ *
+ * Returns a { ID, content } ref with ctrl-links resolved and content
+ * JSON-stringified — the same shape getTemplateForType() returns — or null if
+ * no template matches.
+ */
+export async function resolveTemplateForDocument(payload, doc, collectionSlug, settings) {
+    let templates;
+    try {
+        const result = await payload.find({
+            collection: 'nitrogen-templates',
+            where: {
+                status: { equals: 'published' },
+            },
+            limit: 10000,
+            depth: 0,
+            sort: '-updatedAt',
+        });
+        templates = result.docs;
+    }
+    catch {
+        return null;
+    }
+    if (!templates.length)
+        return null;
+    const context = buildTemplateContext(doc, collectionSlug, settings);
+    let bestMatch = null;
+    let bestScore = -1;
+    for (const template of templates) {
+        const associatedCollection = template.associatedCollection ?? '';
+        // Skip header/footer/not_found templates — resolved separately.
+        if (RESERVED_TEMPLATE_TYPES.includes(associatedCollection)) {
+            continue;
+        }
+        const conditionsData = parseConditions(template.templateConditions);
+        let score;
+        if (conditionsData && Array.isArray(conditionsData.conditionGroups)) {
+            score = evaluateConditions(template.templateConditions, context);
+        }
+        else {
+            // Legacy fallback (php:106-132): match by associatedCollection.
+            score = associatedCollection === collectionSlug ? 1 : false;
+        }
+        // Highest score wins; ties resolve to the first encountered template, which
+        // (thanks to the -updatedAt sort) is the most recently updated.
+        if (score !== false && score > bestScore) {
+            bestScore = score;
+            bestMatch = template;
+        }
+    }
+    if (!bestMatch)
+        return null;
+    let resolved = null;
+    if (bestMatch.nitrogenData) {
+        try {
+            resolved = await resolveCtrlLinksInNitrogenData(payload, bestMatch.nitrogenData, settings);
+        }
+        catch {
+            resolved = null;
+        }
+    }
+    return {
+        ID: bestMatch.id,
+        content: resolved ? JSON.stringify(resolved) : '[]',
+    };
+}

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/dist/globals/NitrogenSettings.js

@@ -27,6 +27,14 @@ export const NitrogenSettings = {
             type: 'text',
             admin: { description: 'Connector token for server communication' },
         },
+        {
+            name: 'nitrogenInstanceUrl',
+            label: 'Nitrogen Instance URL',
+            type: 'text',
+            admin: {
+                description: 'Base URL of the Nitrogen instance hosting the MCP server (the agent endpoint is this + "/mcp"). Leave blank to use the hosted app.',
+            },
+        },
         {
             type: 'row',
             fields: [

package/dist/index.d.ts

@@ -28,6 +28,12 @@ export interface NitrogenConnectorPluginOptions {
      * inventory. These do not need to be editor-enabled.
      */
     indexCollections?: string[];
+    /**
+     * Slug of the auth-enabled collection that owns MCP agent credentials. When
+     * omitted, the first collection with `auth` enabled is used (falling back to
+     * `users`).
+     */
+    userCollection?: string;
 }
 export declare const nitrogenConnectorPlugin: (options?: NitrogenConnectorPluginOptions) => any;
 export { NitrogenTemplates } from "./collections/NitrogenTemplates.js";

package/dist/index.js

@@ -12,6 +12,8 @@ import { menuEndpoints } from "./endpoints/menu.js";
 import { createCollectionEndpoints } from "./endpoints/collection-endpoints.js";
 import { createComponentInventoryEndpoints } from './endpoints/component-inventory.js';
 import { batchEndpoints } from "./endpoints/batch.js";
+import { sitemapEndpoints } from "./endpoints/sitemap.js";
+import { createAgentAuthEndpoints } from "./endpoints/agent-auth.js";
 import { registerCollection } from "./collection-registry.js";
 import { deleteDocumentUsage, reindexDocumentUsage, syncComponentCatalog, } from './inventory/indexing.js';
 /** Fields required by Nitrogen that will be injected into collections if missing */
@@ -42,6 +44,11 @@ export const nitrogenConnectorPlugin = (options = {}) => (incomingConfig) => {
         return incomingConfig;
     }
     const config = { ...incomingConfig };
+    // The auth collection that owns MCP agent credentials. Prefer the explicit
+    // option, else the first auth-enabled collection, else `users`.
+    const userCollectionSlug = options.userCollection ||
+        (incomingConfig.collections || []).find((col) => col.auth)?.slug ||
+        "users";
     const inventoryCollections = Array.from(new Set([
         ...(options.collections || []),
         ...(options.indexCollections || []),
@@ -94,6 +101,8 @@ export const nitrogenConnectorPlugin = (options = {}) => (incomingConfig) => {
         ...collectionsEndpoints,
         ...menuEndpoints,
         ...batchEndpoints,
+        ...sitemapEndpoints,
+        ...createAgentAuthEndpoints(userCollectionSlug),
         ...createComponentInventoryEndpoints({
             collections: inventoryCollections,
             componentManifest: options.componentManifest,
@@ -224,6 +233,55 @@ export const nitrogenConnectorPlugin = (options = {}) => (incomingConfig) => {
         }
         config.collections[existingIndex] = withInventoryHooks(config.collections[existingIndex], slug);
     }
+    // Inject MCP agent-credential storage + management UI onto the auth users
+    // collection. The hashed secret is never exposed via the API.
+    const usersIndex = (config.collections || []).findIndex((col) => col.slug === userCollectionSlug);
+    if (usersIndex === -1) {
+        console.warn(`[@nitrogenbuilder/connector-payload] Users collection "${userCollectionSlug}" not found; ` +
+            `MCP agent credentials cannot be stored. Pass the "userCollection" option if your auth collection differs.`);
+    }
+    else {
+        const usersCol = config.collections[usersIndex];
+        const usersFieldNames = new Set((usersCol.fields || [])
+            .filter((f) => "name" in f && !!f.name)
+            .map((f) => f.name));
+        const agentFields = [];
+        if (!usersFieldNames.has("nitrogenAgentTokenHash")) {
+            agentFields.push({
+                name: "nitrogenAgentTokenHash",
+                type: "text",
+                access: { read: () => false },
+                admin: { hidden: true, readOnly: true },
+            });
+        }
+        if (!usersFieldNames.has("nitrogenAgentTokenCreated")) {
+            agentFields.push({
+                name: "nitrogenAgentTokenCreated",
+                type: "number",
+                admin: { hidden: true, readOnly: true },
+            });
+        }
+        if (!usersFieldNames.has("nitrogenAgentCredentialUI")) {
+            agentFields.push({
+                name: "nitrogenAgentCredentialUI",
+                type: "ui",
+                admin: {
+                    components: {
+                        Field: {
+                            path: "@nitrogenbuilder/connector-payload/components/NitrogenAgentCredential#NitrogenAgentCredential",
+                            clientProps: { apiUrl: "/api/nitrogen/v1" },
+                        },
+                    },
+                },
+            });
+        }
+        if (agentFields.length > 0) {
+            config.collections[usersIndex] = {
+                ...usersCol,
+                fields: [...usersCol.fields, ...agentFields],
+            };
+        }
+    }
     return config;
 };
 // Re-export for consumers who need direct access

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nitrogenbuilder/connector-payload",
-  "version": "0.1.43",
+  "version": "0.1.50",
   "description": "Nitrogen page builder connector plugin for Payload CMS 3.x",
   "author": "Leonardo Dentzien <leo@torchmedia.ca>",
   "type": "module",
@@ -56,6 +56,9 @@
     "@nitrogenbuilder/types": "link:../monogen/packages/types"
   },
   "pnpm": {
-    "onlyBuiltDependencies": ["esbuild", "sharp"]
+    "onlyBuiltDependencies": [
+      "esbuild",
+      "sharp"
+    ]
   }
-}
+}