@nitrogenbuilder/connector-payload 1.1.0 → 1.1.1

package/dist/collections/NitrogenComponentUsage.js

@@ -25,10 +25,6 @@ export const NitrogenComponentUsage = {
             type: 'text',
             required: true,
         },
-        {
-            name: 'depth',
-            type: 'number',
-        },
         {
             name: 'sourceCollection',
             type: 'text',
@@ -56,26 +52,12 @@ export const NitrogenComponentUsage = {
             name: 'sourceStatus',
             type: 'text',
         },
+        // Usage answers "which components appear in which documents". A module's
+        // position in the tree is deliberately not stored: nothing read it, and
+        // keeping it meant every reorder rewrote every row of the document.
         {
             name: 'moduleId',
             type: 'text',
         },
-        {
-            name: 'modulePath',
-            type: 'text',
-            required: true,
-        },
-        {
-            name: 'parentComponentName',
-            type: 'text',
-        },
-        {
-            name: 'parentModuleId',
-            type: 'text',
-        },
-        {
-            name: 'parentModulePath',
-            type: 'text',
-        },
     ],
 };

package/dist/components/NitrogenComponentInventoryClient.js

@@ -548,7 +548,7 @@ export default function NitrogenComponentInventoryClient({ adminRoute, component
                                                             display: 'block',
                                                             padding: 12,
                                                             textDecoration: 'none',
-                                                        }, children: [_jsx("div", { style: { fontWeight: 600 }, children: usage.sourceTitle || usage.sourceSlug || usage.sourceDocumentId }), _jsxs("div", { style: { color: payloadTheme.mutedText, fontSize: 12, marginTop: 2 }, children: [usage.sourceCollection, " - ", usage.modulePath] })] }, usage.usageKey))) })) : (_jsx("p", { style: { color: payloadTheme.mutedText, margin: 0 }, children: "No indexed usages yet." }))] }), _jsxs("div", { children: [_jsx("h3", { style: { color: payloadTheme.text, margin: '0 0 10px', fontSize: 15 }, children: "Props" }), definition ? (Object.values(definition.categories).map((category) => renderCategory(category))) : (_jsx("p", { style: { color: payloadTheme.mutedText, margin: 0 }, children: "No manifest definition available." }))] }), _jsxs("div", { children: [_jsx("h3", { style: { color: payloadTheme.text, margin: '0 0 10px', fontSize: 15 }, children: "Update Prop Across Site" }), editableProps.length ? (_jsxs("div", { style: {
+                                                        }, children: [_jsx("div", { style: { fontWeight: 600 }, children: usage.sourceTitle || usage.sourceSlug || usage.sourceDocumentId }), _jsxs("div", { style: { color: payloadTheme.mutedText, fontSize: 12, marginTop: 2 }, children: [usage.sourceCollection, usage.sourceSlug ? ` - ${usage.sourceSlug}` : ''] })] }, usage.usageKey))) })) : (_jsx("p", { style: { color: payloadTheme.mutedText, margin: 0 }, children: "No indexed usages yet." }))] }), _jsxs("div", { children: [_jsx("h3", { style: { color: payloadTheme.text, margin: '0 0 10px', fontSize: 15 }, children: "Props" }), definition ? (Object.values(definition.categories).map((category) => renderCategory(category))) : (_jsx("p", { style: { color: payloadTheme.mutedText, margin: 0 }, children: "No manifest definition available." }))] }), _jsxs("div", { children: [_jsx("h3", { style: { color: payloadTheme.text, margin: '0 0 10px', fontSize: 15 }, children: "Update Prop Across Site" }), editableProps.length ? (_jsxs("div", { style: {
                                                         border: `1px solid ${payloadTheme.border}`,
                                                         borderRadius: 8,
                                                         display: 'grid',

package/dist/inventory/indexing.d.ts

@@ -6,12 +6,7 @@ export declare const NITROGEN_COMPONENT_CATALOG_COLLECTION = "nitrogen-component
 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;

package/dist/inventory/indexing.js

@@ -10,50 +10,41 @@ function moduleNameFromNode(node) {
     }
     return null;
 }
-function collectUsageFromTree(modules, pathPrefix, results, parentContext, depth = 0) {
+function collectUsageFromTree(modules, pathPrefix, results) {
     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);
+        // The tree path is no longer stored, but it is still the identity of last
+        // resort for a node that carries no id of its own. Such a node reverts to
+        // the old positional behaviour and churns when the tree is reordered.
+        const modulePath = `${pathPrefix}[${index}]`;
         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);
+                collectUsageFromTree(children, `${modulePath}.props.children`, results);
             }
             else if (children && typeof children === 'object') {
                 for (const [slotName, slotChildren] of Object.entries(children)) {
-                    collectUsageFromTree(slotChildren, `${modulePath}.props.children.${slotName}`, results, currentContext, depth + 1);
+                    collectUsageFromTree(slotChildren, `${modulePath}.props.children.${slotName}`, results);
                 }
             }
         }
         if (Array.isArray(node.children)) {
-            collectUsageFromTree(node.children, `${modulePath}.children`, results, currentContext, depth + 1);
+            collectUsageFromTree(node.children, `${modulePath}.children`, results);
         }
     });
 }
@@ -84,62 +75,77 @@ export async function findAllDocs(payload, collection, options, req) {
     }
     return docs;
 }
-async function deleteUsageDocs(payload, docs, req) {
-    for (const doc of docs) {
-        await payload.delete({
-            collection: NITROGEN_COMPONENT_USAGE_COLLECTION,
-            id: doc.id,
-            overrideAccess: true,
-            req,
-        });
-    }
+/**
+ * Delete usage rows in one bulk statement rather than paginating the ids and
+ * issuing a `payload.delete` per row. Usage is rebuilt wholesale on every save,
+ * so a document with N modules previously cost N deletes (plus the finds to
+ * discover them) on the critical path of the save transaction.
+ */
+async function deleteUsageDocsWhere(payload, where, req) {
+    await payload.delete({
+        collection: NITROGEN_COMPONENT_USAGE_COLLECTION,
+        overrideAccess: true,
+        req,
+        where,
+    });
 }
-async function findUsageDocsForSource(payload, sourceCollection, sourceDocumentId, req) {
-    return findAllDocs(payload, NITROGEN_COMPONENT_USAGE_COLLECTION, {
-        limit: 100,
-        select: {
-            id: true,
-        },
-        where: {
-            and: [
-                {
-                    sourceCollection: {
-                        equals: sourceCollection,
-                    },
+function usageDocsForSourceWhere(sourceCollection, sourceDocumentId) {
+    return {
+        and: [
+            {
+                sourceCollection: {
+                    equals: sourceCollection,
                 },
-                {
-                    sourceDocumentId: {
-                        equals: sourceDocumentId,
-                    },
+            },
+            {
+                sourceDocumentId: {
+                    equals: sourceDocumentId,
                 },
-            ],
-        },
-    }, req);
+            },
+        ],
+    };
+}
+function usageKeyFor(sourceCollection, sourceDocumentId, record) {
+    return `${sourceCollection}:${sourceDocumentId}:${record.moduleId}:${record.componentName}`;
+}
+function usageSourceFields(doc) {
+    return {
+        sourceTitle: doc.title || '',
+        sourceSlug: doc.slug || '',
+        sourceStatus: doc.status || doc._status || '',
+    };
+}
+/**
+ * `componentName`, `moduleId`, `sourceCollection` and `sourceDocumentId` are all
+ * encoded in the usage key, so a key match already implies they agree; the
+ * source fields are reconciled separately by a single bulk update. That leaves
+ * only `sourceType`, which is checked defensively so a row written with the
+ * wrong value can still heal.
+ */
+function usageRowIsCurrent(row, sourceType) {
+    return row.sourceType === sourceType;
+}
+function usageRowData(sourceCollection, sourceType, sourceDocumentId, sourceFields, record) {
+    return {
+        usageKey: usageKeyFor(sourceCollection, sourceDocumentId, record),
+        componentName: record.componentName,
+        sourceCollection,
+        sourceType,
+        sourceDocumentId,
+        ...sourceFields,
+        moduleId: record.moduleId,
+    };
 }
 async function createUsageDocs(payload, sourceCollection, sourceType, doc, req) {
     const sourceDocumentId = String(doc.id);
+    const sourceFields = usageSourceFields(doc);
     const usageRecords = extractComponentUsageRecords(doc.nitrogenData);
     for (const record of usageRecords) {
         await payload.create({
             collection: NITROGEN_COMPONENT_USAGE_COLLECTION,
             overrideAccess: true,
             req,
-            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 || '',
-            },
+            data: usageRowData(sourceCollection, sourceType, sourceDocumentId, sourceFields, record),
         });
     }
     return usageRecords.length;
@@ -193,23 +199,72 @@ export async function syncComponentCatalog(payload, manifestInput, req) {
 }
 export async function reindexDocumentUsage(payload, sourceCollection, doc, sourceType = 'document', req) {
     const sourceDocumentId = String(doc.id);
-    const docsForSource = await findUsageDocsForSource(payload, sourceCollection, sourceDocumentId, req);
-    await deleteUsageDocs(payload, docsForSource, req);
-    return createUsageDocs(payload, sourceCollection, sourceType, doc, req);
+    const sourceWhere = usageDocsForSourceWhere(sourceCollection, sourceDocumentId);
+    const sourceFields = usageSourceFields(doc);
+    const usageRecords = extractComponentUsageRecords(doc.nitrogenData);
+    // Usage rows describe tree *structure* only — nothing derived from module
+    // props or content. Editing copy therefore leaves every row identical, so
+    // diffing turns the common autosave case into zero writes instead of a full
+    // delete-and-recreate of every row on the save's critical path.
+    const existingRows = await findAllDocs(payload, NITROGEN_COMPONENT_USAGE_COLLECTION, { limit: 200, where: sourceWhere }, req);
+    const desiredByKey = new Map();
+    for (const record of usageRecords) {
+        desiredByKey.set(usageKeyFor(sourceCollection, sourceDocumentId, record), record);
+    }
+    const existingByKey = new Map();
+    const staleKeys = [];
+    for (const row of existingRows) {
+        if (desiredByKey.has(row.usageKey))
+            existingByKey.set(row.usageKey, row);
+        else
+            staleKeys.push(row.usageKey);
+    }
+    if (staleKeys.length > 0) {
+        await deleteUsageDocsWhere(payload, { usageKey: { in: staleKeys } }, req);
+    }
+    // Title/slug/status are identical across every row of the document, so when
+    // they change one bulk update fixes the whole set rather than N row updates.
+    const sourceFieldsStale = existingRows.some((row) => (row.sourceTitle || '') !== sourceFields.sourceTitle ||
+        (row.sourceSlug || '') !== sourceFields.sourceSlug ||
+        (row.sourceStatus || '') !== sourceFields.sourceStatus);
+    if (sourceFieldsStale && existingByKey.size > 0) {
+        await payload.update({
+            collection: NITROGEN_COMPONENT_USAGE_COLLECTION,
+            overrideAccess: true,
+            req,
+            where: sourceWhere,
+            data: sourceFields,
+        });
+    }
+    for (const [usageKey, record] of desiredByKey) {
+        const row = existingByKey.get(usageKey);
+        const data = usageRowData(sourceCollection, sourceType, sourceDocumentId, sourceFields, record);
+        if (!row) {
+            await payload.create({
+                collection: NITROGEN_COMPONENT_USAGE_COLLECTION,
+                overrideAccess: true,
+                req,
+                data,
+            });
+        }
+        else if (!usageRowIsCurrent(row, sourceType)) {
+            await payload.update({
+                collection: NITROGEN_COMPONENT_USAGE_COLLECTION,
+                id: row.id,
+                overrideAccess: true,
+                req,
+                data,
+            });
+        }
+    }
+    return usageRecords.length;
 }
 export async function deleteDocumentUsage(payload, sourceCollection, sourceDocumentId, req) {
-    const docsForSource = await findUsageDocsForSource(payload, sourceCollection, String(sourceDocumentId), req);
-    await deleteUsageDocs(payload, docsForSource, req);
+    await deleteUsageDocsWhere(payload, usageDocsForSourceWhere(sourceCollection, String(sourceDocumentId)), req);
 }
 export async function reindexAllComponentInventory(payload, collections, manifestInput, req) {
     const entries = await syncComponentCatalog(payload, manifestInput, req);
-    const usageDocs = await findAllDocs(payload, NITROGEN_COMPONENT_USAGE_COLLECTION, {
-        limit: 200,
-        select: {
-            id: true,
-        },
-    }, req);
-    await deleteUsageDocs(payload, usageDocs, req);
+    await deleteUsageDocsWhere(payload, { id: { exists: true } }, req);
     let documentCount = 0;
     let usageCount = 0;
     for (const collection of collections) {

package/dist/types.d.ts

@@ -152,7 +152,6 @@ export interface NitrogenComponentUsageDoc {
     id: string | number;
     usageKey: string;
     componentName: string;
-    depth?: number;
     sourceCollection: string;
     sourceType: string;
     sourceDocumentId: string;
@@ -160,10 +159,6 @@ export interface NitrogenComponentUsageDoc {
     sourceSlug?: string;
     sourceStatus?: string;
     moduleId?: string;
-    modulePath: string;
-    parentComponentName?: string;
-    parentModuleId?: string;
-    parentModulePath?: string;
 }
 export interface NitrogenInventorySourceDoc {
     id: string | number;

package/package.json

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