@nitrogenbuilder/connector-payload 0.1.34 → 0.1.35

package/dist/index.js

@@ -1,5 +1,8 @@
 import { NitrogenTemplates } from "./collections/NitrogenTemplates";
+import { NitrogenComponentCatalog } from './collections/NitrogenComponentCatalog';
+import { NitrogenComponentUsage } from './collections/NitrogenComponentUsage';
 import { NitrogenSettings } from "./globals/NitrogenSettings";
+import { NitrogenComponents } from './globals/NitrogenComponents';
 import { templatesEndpoints } from "./endpoints/templates";
 import { mediaEndpoints } from "./endpoints/media";
 import { nitrogenSettingsEndpoints } from "./endpoints/nitrogen-settings";
@@ -7,8 +10,10 @@ import { allEndpoints } from "./endpoints/all";
 import { collectionsEndpoints } from "./endpoints/collections";
 import { menuEndpoints } from "./endpoints/menu";
 import { createCollectionEndpoints } from "./endpoints/collection-endpoints";
+import { createComponentInventoryEndpoints } from './endpoints/component-inventory';
 import { batchEndpoints } from "./endpoints/batch";
 import { registerCollection } from "./collection-registry";
+import { deleteDocumentUsage, reindexDocumentUsage, syncComponentCatalog, } from './inventory/indexing';
 /** Fields required by Nitrogen that will be injected into collections if missing */
 const nitrogenRequiredFields = [
     {
@@ -37,10 +42,48 @@ export const nitrogenConnectorPlugin = (options = {}) => (incomingConfig) => {
         return incomingConfig;
     }
     const config = { ...incomingConfig };
+    const inventoryCollections = Array.from(new Set([
+        ...(options.collections || []),
+        ...(options.indexCollections || []),
+        'nitrogen-templates',
+    ]));
+    const createAfterChangeHook = (collectionSlug) => {
+        return async ({ doc, req }) => {
+            if (doc) {
+                await reindexDocumentUsage(req.payload, collectionSlug, doc, collectionSlug === 'nitrogen-templates' ? 'template' : 'document');
+            }
+            return doc;
+        };
+    };
+    const createAfterDeleteHook = (collectionSlug) => {
+        return async ({ doc, id, req, }) => {
+            const sourceId = doc?.id ?? id;
+            if (sourceId !== undefined) {
+                await deleteDocumentUsage(req.payload, collectionSlug, sourceId);
+            }
+            return doc;
+        };
+    };
+    const withInventoryHooks = (collection, collectionSlug) => {
+        const hooks = collection.hooks || {};
+        return {
+            ...collection,
+            hooks: {
+                ...hooks,
+                afterChange: [...(hooks.afterChange || []), createAfterChangeHook(collectionSlug)],
+                afterDelete: [...(hooks.afterDelete || []), createAfterDeleteHook(collectionSlug)],
+            },
+        };
+    };
     // Add Nitrogen templates collection
-    config.collections = [...(config.collections || []), NitrogenTemplates];
-    // Add Nitrogen global settings
-    config.globals = [...(config.globals || []), NitrogenSettings];
+    config.collections = [
+        ...(config.collections || []),
+        withInventoryHooks(NitrogenTemplates, 'nitrogen-templates'),
+        NitrogenComponentCatalog,
+        NitrogenComponentUsage,
+    ];
+    // Add Nitrogen globals
+    config.globals = [...(config.globals || []), NitrogenSettings, NitrogenComponents];
     // Add Nitrogen API endpoints
     config.endpoints = [
         ...(config.endpoints || []),
@@ -51,7 +94,45 @@ export const nitrogenConnectorPlugin = (options = {}) => (incomingConfig) => {
         ...collectionsEndpoints,
         ...menuEndpoints,
         ...batchEndpoints,
+        ...createComponentInventoryEndpoints({
+            collections: inventoryCollections,
+            componentManifest: options.componentManifest,
+        }),
     ];
+    const existingOnInit = config.onInit;
+    config.onInit = async (payload) => {
+        if (existingOnInit) {
+            await existingOnInit(payload);
+        }
+        try {
+            await syncComponentCatalog(payload, options.componentManifest);
+        }
+        catch (error) {
+            payload.logger.error(`[@nitrogenbuilder/connector-payload] Failed to sync component catalog: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        for (const slug of ['nitrogen-components']) {
+            try {
+                await payload.findGlobal({
+                    slug,
+                    depth: 0,
+                    overrideAccess: true,
+                });
+            }
+            catch {
+                try {
+                    await payload.updateGlobal({
+                        slug,
+                        data: {},
+                        depth: 0,
+                        overrideAccess: true,
+                    });
+                }
+                catch (error) {
+                    payload.logger.warn(`[@nitrogenbuilder/connector-payload] Could not initialize global "${slug}": ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+    };
     // Register templates collection
     registerCollection("nitrogen-templates", "nitrogen-templates", "/nitrogen-templates/[slug]");
     registerCollection("nitrogen_template", "nitrogen-templates", "/nitrogen-templates/[slug]");
@@ -133,6 +214,16 @@ export const nitrogenConnectorPlugin = (options = {}) => (incomingConfig) => {
         // Register in the collection registry for the `all` endpoint
         registerCollection(slug, slug, routePattern);
     }
+    for (const slug of inventoryCollections) {
+        if (slug === 'nitrogen-templates')
+            continue;
+        const existingIndex = (config.collections || []).findIndex((collection) => collection.slug === slug);
+        if (existingIndex === -1) {
+            console.warn(`[@nitrogenbuilder/connector-payload] Index collection "${slug}" not found in config.`);
+            continue;
+        }
+        config.collections[existingIndex] = withInventoryHooks(config.collections[existingIndex], slug);
+    }
     return config;
 };
 // Re-export for consumers who need direct access

package/dist/inventory/indexing.d.ts

@@ -0,0 +1,31 @@
+import type { ComponentManifestEntry } from '@nitrogenbuilder/types';
+import type { Payload, Where } from 'payload';
+import type { NitrogenInventorySourceDoc } from '../types';
+import { type NitrogenComponentManifestInput } from './manifest';
+export declare const NITROGEN_COMPONENT_CATALOG_COLLECTION = "nitrogen-component-catalog";
+export declare const NITROGEN_COMPONENT_USAGE_COLLECTION = "nitrogen-component-usage";
+type ComponentUsageRecord = {
+    componentName: string;
+    depth: number;
+    moduleId: string;
+    modulePath: string;
+    parentComponentName?: string;
+    parentModuleId?: string;
+    parentModulePath?: string;
+};
+type ReindexResult = {
+    catalogCount: number;
+    documentCount: number;
+    usageCount: number;
+};
+export declare function extractComponentUsageRecords(modules: unknown): ComponentUsageRecord[];
+export declare function findAllDocs<T extends object>(payload: Payload, collection: string, options?: {
+    limit?: number;
+    select?: Record<string, true>;
+    where?: Where;
+}): Promise<T[]>;
+export declare function syncComponentCatalog(payload: Payload, manifestInput?: NitrogenComponentManifestInput): Promise<ComponentManifestEntry[]>;
+export declare function reindexDocumentUsage(payload: Payload, sourceCollection: string, doc: NitrogenInventorySourceDoc, sourceType?: 'document' | 'template'): Promise<number>;
+export declare function deleteDocumentUsage(payload: Payload, sourceCollection: string, sourceDocumentId: string | number): Promise<void>;
+export declare function reindexAllComponentInventory(payload: Payload, collections: string[], manifestInput?: NitrogenComponentManifestInput): Promise<ReindexResult>;
+export {};

package/dist/inventory/indexing.js

@@ -0,0 +1,230 @@
+import { resolveComponentManifest, } from './manifest';
+export const NITROGEN_COMPONENT_CATALOG_COLLECTION = 'nitrogen-component-catalog';
+export const NITROGEN_COMPONENT_USAGE_COLLECTION = 'nitrogen-component-usage';
+function moduleNameFromNode(node) {
+    const value = node.module;
+    if (typeof value === 'string')
+        return value;
+    if (value && typeof value === 'object' && typeof value.name === 'string') {
+        return String(value.name);
+    }
+    return null;
+}
+function collectUsageFromTree(modules, pathPrefix, results, parentContext, depth = 0) {
+    if (!Array.isArray(modules))
+        return;
+    modules.forEach((maybeNode, index) => {
+        if (!maybeNode || typeof maybeNode !== 'object')
+            return;
+        const node = maybeNode;
+        const modulePath = `${pathPrefix}[${index}]`;
+        const componentName = moduleNameFromNode(node);
+        const moduleId = typeof node.id === 'string' || typeof node.id === 'number'
+            ? String(node.id)
+            : modulePath;
+        const currentContext = componentName
+            ? {
+                componentName,
+                moduleId,
+                modulePath,
+            }
+            : parentContext;
+        if (componentName) {
+            results.push({
+                componentName,
+                depth,
+                moduleId,
+                modulePath,
+                parentComponentName: parentContext?.componentName,
+                parentModuleId: parentContext?.moduleId,
+                parentModulePath: parentContext?.modulePath,
+            });
+        }
+        const props = node.props;
+        if (props && typeof props === 'object') {
+            const children = props.children;
+            if (Array.isArray(children)) {
+                collectUsageFromTree(children, `${modulePath}.props.children`, results, currentContext, depth + 1);
+            }
+            else if (children && typeof children === 'object') {
+                for (const [slotName, slotChildren] of Object.entries(children)) {
+                    collectUsageFromTree(slotChildren, `${modulePath}.props.children.${slotName}`, results, currentContext, depth + 1);
+                }
+            }
+        }
+        if (Array.isArray(node.children)) {
+            collectUsageFromTree(node.children, `${modulePath}.children`, results, currentContext, depth + 1);
+        }
+    });
+}
+export function extractComponentUsageRecords(modules) {
+    const results = [];
+    collectUsageFromTree(modules, 'modules', results);
+    return results;
+}
+export async function findAllDocs(payload, collection, options) {
+    const docs = [];
+    let page = 1;
+    let hasNextPage = true;
+    while (hasNextPage) {
+        const result = await payload.find({
+            collection: collection,
+            depth: 0,
+            limit: options?.limit ?? 200,
+            page,
+            overrideAccess: true,
+            pagination: true,
+            select: options?.select,
+            where: options?.where,
+        });
+        docs.push(...result.docs);
+        hasNextPage = Boolean(result.hasNextPage);
+        page += 1;
+    }
+    return docs;
+}
+async function deleteUsageDocs(payload, docs) {
+    for (const doc of docs) {
+        await payload.delete({
+            collection: NITROGEN_COMPONENT_USAGE_COLLECTION,
+            id: doc.id,
+            overrideAccess: true,
+        });
+    }
+}
+async function findUsageDocsForSource(payload, sourceCollection, sourceDocumentId) {
+    return findAllDocs(payload, NITROGEN_COMPONENT_USAGE_COLLECTION, {
+        limit: 100,
+        select: {
+            id: true,
+        },
+        where: {
+            and: [
+                {
+                    sourceCollection: {
+                        equals: sourceCollection,
+                    },
+                },
+                {
+                    sourceDocumentId: {
+                        equals: sourceDocumentId,
+                    },
+                },
+            ],
+        },
+    });
+}
+async function createUsageDocs(payload, sourceCollection, sourceType, doc) {
+    const sourceDocumentId = String(doc.id);
+    const usageRecords = extractComponentUsageRecords(doc.nitrogenData);
+    for (const record of usageRecords) {
+        await payload.create({
+            collection: NITROGEN_COMPONENT_USAGE_COLLECTION,
+            overrideAccess: true,
+            data: {
+                usageKey: `${sourceCollection}:${sourceDocumentId}:${record.moduleId}:${record.modulePath}:${record.componentName}`,
+                componentName: record.componentName,
+                depth: record.depth,
+                sourceCollection,
+                sourceType,
+                sourceDocumentId,
+                sourceTitle: doc.title || '',
+                sourceSlug: doc.slug || '',
+                sourceStatus: doc.status || doc._status || '',
+                moduleId: record.moduleId,
+                modulePath: record.modulePath,
+                parentComponentName: record.parentComponentName || '',
+                parentModuleId: record.parentModuleId || '',
+                parentModulePath: record.parentModulePath || '',
+            },
+        });
+    }
+    return usageRecords.length;
+}
+export async function syncComponentCatalog(payload, manifestInput) {
+    const manifest = await resolveComponentManifest(manifestInput);
+    const entries = manifest.components || [];
+    const existingDocs = await findAllDocs(payload, NITROGEN_COMPONENT_CATALOG_COLLECTION);
+    const existingByName = new Map(existingDocs.map((doc) => [doc.componentName, doc]));
+    const nextNames = new Set(entries.map((entry) => entry.name));
+    for (const entry of entries) {
+        const existing = existingByName.get(entry.name);
+        const data = {
+            componentName: entry.name,
+            scope: entry.scope || '',
+            sidebarCategory: entry.sidebarCategory || '',
+            icon: entry.icon || '',
+            definition: entry,
+            source: manifest.source || '',
+        };
+        if (existing) {
+            await payload.update({
+                collection: NITROGEN_COMPONENT_CATALOG_COLLECTION,
+                id: existing.id,
+                data,
+                overrideAccess: true,
+            });
+        }
+        else {
+            await payload.create({
+                collection: NITROGEN_COMPONENT_CATALOG_COLLECTION,
+                data,
+                overrideAccess: true,
+            });
+        }
+    }
+    for (const existing of existingDocs) {
+        if (!nextNames.has(existing.componentName)) {
+            await payload.delete({
+                collection: NITROGEN_COMPONENT_CATALOG_COLLECTION,
+                id: existing.id,
+                overrideAccess: true,
+            });
+        }
+    }
+    return entries;
+}
+export async function reindexDocumentUsage(payload, sourceCollection, doc, sourceType = 'document') {
+    const sourceDocumentId = String(doc.id);
+    const docsForSource = await findUsageDocsForSource(payload, sourceCollection, sourceDocumentId);
+    await deleteUsageDocs(payload, docsForSource);
+    return createUsageDocs(payload, sourceCollection, sourceType, doc);
+}
+export async function deleteDocumentUsage(payload, sourceCollection, sourceDocumentId) {
+    const docsForSource = await findUsageDocsForSource(payload, sourceCollection, String(sourceDocumentId));
+    await deleteUsageDocs(payload, docsForSource);
+}
+export async function reindexAllComponentInventory(payload, collections, manifestInput) {
+    const entries = await syncComponentCatalog(payload, manifestInput);
+    const usageDocs = await findAllDocs(payload, NITROGEN_COMPONENT_USAGE_COLLECTION, {
+        limit: 200,
+        select: {
+            id: true,
+        },
+    });
+    await deleteUsageDocs(payload, usageDocs);
+    let documentCount = 0;
+    let usageCount = 0;
+    for (const collection of collections) {
+        const docs = await findAllDocs(payload, collection, {
+            limit: 100,
+            select: {
+                id: true,
+                title: true,
+                slug: true,
+                status: true,
+                _status: true,
+                nitrogenData: true,
+            },
+        });
+        for (const doc of docs) {
+            documentCount += 1;
+            usageCount += await createUsageDocs(payload, collection, collection === 'nitrogen-templates' ? 'template' : 'document', doc);
+        }
+    }
+    return {
+        catalogCount: entries.length,
+        documentCount,
+        usageCount,
+    };
+}

package/dist/inventory/manifest.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentManifest, ComponentManifestEntry } from '@nitrogenbuilder/types';
+export type NitrogenComponentManifestInput = ComponentManifest | ComponentManifestEntry[] | (() => Promise<ComponentManifest | ComponentManifestEntry[]> | ComponentManifest | ComponentManifestEntry[]);
+export declare function resolveComponentManifest(input?: NitrogenComponentManifestInput): Promise<ComponentManifest>;

package/dist/inventory/manifest.js

@@ -0,0 +1,22 @@
+export async function resolveComponentManifest(input) {
+    if (!input) {
+        return {
+            components: [],
+            generatedAt: new Date().toISOString(),
+            source: 'empty',
+        };
+    }
+    const resolved = typeof input === 'function' ? await input() : input;
+    if (Array.isArray(resolved)) {
+        return {
+            components: resolved,
+            generatedAt: new Date().toISOString(),
+            source: 'array',
+        };
+    }
+    return {
+        components: resolved.components || [],
+        generatedAt: resolved.generatedAt || new Date().toISOString(),
+        source: resolved.source,
+    };
+}

package/dist/types.d.ts

@@ -4,7 +4,7 @@
  * Document interfaces matching the Payload collection/global schemas,
  * plus request body shapes used by the API endpoints.
  */
-import type { BuilderModule } from '@nitrogenbuilder/types';
+import type { BuilderModule, ComponentManifestEntry } from '@nitrogenbuilder/types';
 export type JsonObject = Record<string, unknown>;
 export type NitrogenModule = BuilderModule;
 interface NitrogenDocBase {
@@ -128,4 +128,38 @@ export interface RenderDataRequestBody {
     /** Which Payload collection to fetch dynamic data from */
     collection?: string;
 }
+export interface NitrogenComponentCatalogDoc {
+    id: string | number;
+    componentName: string;
+    scope?: string;
+    sidebarCategory?: string;
+    icon?: string;
+    definition?: ComponentManifestEntry | JsonObject;
+    source?: string;
+}
+export interface NitrogenComponentUsageDoc {
+    id: string | number;
+    usageKey: string;
+    componentName: string;
+    depth?: number;
+    sourceCollection: string;
+    sourceType: string;
+    sourceDocumentId: string;
+    sourceTitle?: string;
+    sourceSlug?: string;
+    sourceStatus?: string;
+    moduleId?: string;
+    modulePath: string;
+    parentComponentName?: string;
+    parentModuleId?: string;
+    parentModulePath?: string;
+}
+export interface NitrogenInventorySourceDoc {
+    id: string | number;
+    title?: string;
+    slug?: string;
+    status?: string;
+    _status?: string;
+    nitrogenData?: JsonObject | JsonObject[];
+}
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nitrogenbuilder/connector-payload",
-  "version": "0.1.34",
+  "version": "0.1.35",
   "description": "Nitrogen page builder connector plugin for Payload CMS 3.x",
   "author": "Leonardo Dentzien <leo@torchmedia.ca>",
   "type": "module",
@@ -35,7 +35,7 @@
   },
   "peerDependencies": {
     "payload": "^3.0.0",
-    "next": "^15.0.0",
+    "next": "^15.0.0 || ^16.0.0",
     "react": "^19.0.0",
     "@payloadcms/ui": "^3.0.0",
     "@nitrogenbuilder/client-react": ">=0.3.0",
@@ -43,8 +43,13 @@
     "@nitrogenbuilder/types": ">=0.3.0"
   },
   "devDependencies": {
+    "@payloadcms/ui": "3.83.0",
+    "next": "16.2.4",
+    "payload": "3.83.0",
     "@types/react": "^19.0.0",
     "@types/node": "^22.0.0",
+    "react": "19.2.5",
+    "react-dom": "19.2.5",
     "typescript": "^5.7.0",
     "@nitrogenbuilder/client-react": "link:../monogen/packages/client-react",
     "@nitrogenbuilder/client-core": "link:../monogen/packages/client-core",