strapi-content-sync-pro 1.0.5 → 1.0.7

package/server/src/services/sync.js

@@ -27,6 +27,41 @@ module.exports = ({ strapi }) => {
     await store.set({ key: LAST_SYNC_STORE_KEY, value: timestamps });
   }
 
+  function getOwnerRelationFieldSet(uid, allowedFields) {
+    const contentType = strapi.contentTypes?.[uid];
+    const attrs = contentType?.attributes || {};
+    const allowed = new Set(allowedFields || []);
+    const set = new Set();
+
+    for (const [field, attr] of Object.entries(attrs)) {
+      // Owner/declaring side only: include relation fields that declare a
+      // target and are not inverse-only markers.
+      if (attr?.type === 'relation' && attr.target && !attr.mappedBy && !attr.inversedBy) {
+        if (allowed.size === 0 || allowed.has(field)) set.add(field);
+      }
+    }
+
+    return set;
+  }
+
+  function selectFieldsForPhase(uid, configuredFields, phase = 'all') {
+    const allowed = Array.isArray(configuredFields) ? configuredFields : [];
+    if (!uid) return allowed;
+    if (phase === 'all') return allowed;
+
+    const ownerRelationFields = getOwnerRelationFieldSet(uid, allowed);
+    if (ownerRelationFields.size === 0) {
+      return phase === 'relations' ? ['documentId', 'syncId', 'updatedAt'] : allowed;
+    }
+
+    if (phase === 'relations') {
+      return ['documentId', 'syncId', 'updatedAt', ...ownerRelationFields];
+    }
+
+    // entities phase: exclude owner-side relation fields
+    return allowed.filter((f) => !ownerRelationFields.has(f));
+  }
+
   return {
     /**
      * Step 6 + 7 + 10 — Execute a manual / incremental sync for every
@@ -39,6 +74,7 @@ module.exports = ({ strapi }) => {
       const configService = plugin().service('config');
       const syncConfigService = plugin().service('syncConfig');
       const syncProfilesService = plugin().service('syncProfiles');
+      const dependencyResolver = plugin().service('dependencyResolver');
       const executionService = plugin().service('syncExecution');
 
       const remoteConfig = await configService.getConfig({ safe: false });
@@ -49,6 +85,47 @@ module.exports = ({ strapi }) => {
       const syncConfig = await syncConfigService.getSyncConfig();
       const enabledTypes = (syncConfig.contentTypes || []).filter((ct) => ct.enabled);
 
+      // Reorder enabled types so dependency targets are processed before
+      // dependents. This improves relation consistency during full sync.
+      const enabledSet = new Set(enabledTypes.map((ct) => ct.uid));
+      const inDegree = new Map();
+      const adjacency = new Map();
+      enabledTypes.forEach((ct) => {
+        inDegree.set(ct.uid, 0);
+        adjacency.set(ct.uid, []);
+      });
+      for (const ct of enabledTypes) {
+        try {
+          const rels = dependencyResolver.analyzeContentType(ct.uid)?.relations || [];
+          for (const rel of rels) {
+            const depUid = rel.target;
+            if (!enabledSet.has(depUid) || depUid === ct.uid) continue;
+            adjacency.get(depUid).push(ct.uid);
+            inDegree.set(ct.uid, (inDegree.get(ct.uid) || 0) + 1);
+          }
+        } catch (_) {
+          // Ignore schema parse failures and keep original order fallback.
+        }
+      }
+      const queue = enabledTypes.map((ct) => ct.uid).filter((uid) => (inDegree.get(uid) || 0) === 0);
+      const orderedUids = [];
+      while (queue.length > 0) {
+        const uid = queue.shift();
+        orderedUids.push(uid);
+        for (const next of adjacency.get(uid) || []) {
+          const deg = (inDegree.get(next) || 0) - 1;
+          inDegree.set(next, deg);
+          if (deg === 0) queue.push(next);
+        }
+      }
+      // Cycle fallback: append any remaining in original order.
+      for (const ct of enabledTypes) {
+        if (!orderedUids.includes(ct.uid)) orderedUids.push(ct.uid);
+      }
+      const enabledTypesOrdered = orderedUids
+        .map((uid) => enabledTypes.find((ct) => ct.uid === uid))
+        .filter(Boolean);
+
       // Pagination — remote + local fetches are chunked to keep memory bounded
       // for large datasets. Page size is a global setting tunable in the Sync tab.
       const globalExec = (await executionService.getGlobalSettings?.()) || {};
@@ -57,7 +134,7 @@ module.exports = ({ strapi }) => {
       const reportHandle = await syncStatsService.createRunReport({
         runType: 'sync_now',
         trigger: 'manual_sync_now',
-        contentTypes: enabledTypes.map((ct) => ct.uid),
+        contentTypes: enabledTypesOrdered.map((ct) => ct.uid),
       });
 
       try {
@@ -71,7 +148,7 @@ module.exports = ({ strapi }) => {
         const conflictStrategy = syncConfig.conflictStrategy || 'latest';
         const results = [];
 
-        for (const ctConfig of enabledTypes) {
+        for (const ctConfig of enabledTypesOrdered) {
           const { uid, direction, fields } = ctConfig;
           const lastSyncAt = timestamps[uid] || null;
           const syncStartTime = new Date().toISOString();
@@ -80,94 +157,103 @@ module.exports = ({ strapi }) => {
           const fieldPolicies = await syncProfilesService.getFieldPoliciesForContentType(uid);
 
           try {
-            // Both sides are fetched in pages of `pageSize` records under the
-            // hood (see utils/fetcher.js). We aggregate per content-type because
-            // the comparator needs the full set to diff by syncId, but each
-            // network/DB call still only returns a bounded chunk.
-            const localRecords = await fetchLocalRecords(strapi, uid, { fields, lastSyncAt, pageSize });
-            const remoteRecords = await fetchRemoteRecords(remoteConfig, uid, { fields, lastSyncAt, pageSize });
-
             const profileForOptions = await syncProfilesService.getActiveProfileForContentType(uid);
             const syncDeletions = !!(profileForOptions?.syncDeletions);
-
-            const diff = compareRecords(localRecords, remoteRecords, {
-              direction,
-              conflictStrategy,
-              syncDeletions,
-            });
+            const executionStrategy = profileForOptions?.executionStrategy || 'hybrid_two_pass';
+            const phases = executionStrategy === 'one_pass' ? ['all'] : ['entities', 'relations'];
 
             let pushed = 0;
             let pulled = 0;
             let errors = 0;
 
-            // Apply field policies to records before pushing/pulling
-            for (const { local } of diff.toPush) {
-              try {
-                const filteredRecord = syncProfilesService.filterFieldsByPolicy(local, fieldPolicies, 'push');
-                await applyRemote(remoteConfig, uid, filteredRecord, fields);
-                pushed++;
-              } catch (err) {
-                errors++;
-                await logService.log({ action: 'push', contentType: uid, syncId: local.syncId, direction: 'push', status: 'error', message: err.message });
+            for (const phase of phases) {
+              const phaseFields = selectFieldsForPhase(uid, fields, phase);
+
+              // Both sides are fetched in pages of `pageSize` records under the
+              // hood (see utils/fetcher.js). We aggregate per content-type because
+              // the comparator needs the full set to diff by syncId, but each
+              // network/DB call still only returns a bounded chunk.
+              const localRecords = await fetchLocalRecords(strapi, uid, { fields: phaseFields, lastSyncAt, pageSize });
+              const remoteRecords = await fetchRemoteRecords(remoteConfig, uid, { fields: phaseFields, lastSyncAt, pageSize });
+
+              const diff = compareRecords(localRecords, remoteRecords, {
+                direction,
+                conflictStrategy,
+                syncDeletions: phase === 'relations' ? false : syncDeletions,
+              });
+
+              // Apply field policies to records before pushing/pulling
+              for (const { local } of diff.toPush) {
+                try {
+                  const filteredRecord = syncProfilesService.filterFieldsByPolicy(local, fieldPolicies, 'push');
+                  await applyRemote(remoteConfig, uid, filteredRecord, phaseFields);
+                  pushed++;
+                } catch (err) {
+                  errors++;
+                  await logService.log({ action: 'push', contentType: uid, syncId: local.syncId, direction: 'push', status: 'error', message: err.message });
+                }
               }
-            }
 
-            for (const { remote } of diff.toPull) {
-              try {
-                const filteredRecord = syncProfilesService.filterFieldsByPolicy(remote, fieldPolicies, 'pull');
-                await applyLocal(strapi, uid, filteredRecord, fields);
-                pulled++;
-              } catch (err) {
-                errors++;
-                await logService.log({ action: 'pull', contentType: uid, syncId: remote.syncId, direction: 'pull', status: 'error', message: err.message });
+              for (const { remote } of diff.toPull) {
+                try {
+                  const filteredRecord = syncProfilesService.filterFieldsByPolicy(remote, fieldPolicies, 'pull');
+                  await applyLocal(strapi, uid, filteredRecord, phaseFields);
+                  pulled++;
+                } catch (err) {
+                  errors++;
+                  await logService.log({ action: 'pull', contentType: uid, syncId: remote.syncId, direction: 'pull', status: 'error', message: err.message });
+                }
               }
-            }
 
-            for (const record of diff.toCreateRemote) {
-              try {
-                const filteredRecord = syncProfilesService.filterFieldsByPolicy(record, fieldPolicies, 'push');
-                await applyRemote(remoteConfig, uid, filteredRecord, fields);
-                pushed++;
-              } catch (err) {
-                errors++;
-                await logService.log({ action: 'create_remote', contentType: uid, syncId: record.syncId, direction: 'push', status: 'error', message: err.message });
+              for (const record of diff.toCreateRemote) {
+                try {
+                  const filteredRecord = syncProfilesService.filterFieldsByPolicy(record, fieldPolicies, 'push');
+                  await applyRemote(remoteConfig, uid, filteredRecord, phaseFields);
+                  pushed++;
+                } catch (err) {
+                  errors++;
+                  await logService.log({ action: 'create_remote', contentType: uid, syncId: record.syncId, direction: 'push', status: 'error', message: err.message });
+                }
               }
-            }
 
-            for (const record of diff.toCreateLocal) {
-              try {
-                const filteredRecord = syncProfilesService.filterFieldsByPolicy(record, fieldPolicies, 'pull');
-                await applyLocal(strapi, uid, filteredRecord, fields);
-                pulled++;
-              } catch (err) {
-                errors++;
-                await logService.log({ action: 'create_local', contentType: uid, syncId: record.syncId, direction: 'pull', status: 'error', message: err.message });
+              for (const record of diff.toCreateLocal) {
+                try {
+                  const filteredRecord = syncProfilesService.filterFieldsByPolicy(record, fieldPolicies, 'pull');
+                  await applyLocal(strapi, uid, filteredRecord, phaseFields);
+                  pulled++;
+                } catch (err) {
+                  errors++;
+                  await logService.log({ action: 'create_local', contentType: uid, syncId: record.syncId, direction: 'pull', status: 'error', message: err.message });
+                }
               }
-            }
 
-            for (const record of diff.toDeleteRemote) {
-              try {
-                await deleteRemote(remoteConfig, uid, record);
-                await logService.log({ action: 'delete_remote', contentType: uid, syncId: record.syncId, direction: 'push', status: 'success', message: `Deleted remote record ${record.syncId}` });
-              } catch (err) {
-                errors++;
-                await logService.log({ action: 'delete_remote', contentType: uid, syncId: record.syncId, direction: 'push', status: 'error', message: err.message });
-              }
-            }
-
-            for (const record of diff.toDeleteLocal) {
-              try {
-                await deleteLocal(strapi, uid, record);
-                await logService.log({ action: 'delete_local', contentType: uid, syncId: record.syncId, direction: 'pull', status: 'success', message: `Deleted local record ${record.syncId}` });
-              } catch (err) {
-                errors++;
-                await logService.log({ action: 'delete_local', contentType: uid, syncId: record.syncId, direction: 'pull', status: 'error', message: err.message });
+              // Deletion handling only in non-relations phase
+              if (phase !== 'relations') {
+                for (const record of diff.toDeleteRemote) {
+                  try {
+                    await deleteRemote(remoteConfig, uid, record);
+                    await logService.log({ action: 'delete_remote', contentType: uid, syncId: record.syncId, direction: 'push', status: 'success', message: `Deleted remote record ${record.syncId}` });
+                  } catch (err) {
+                    errors++;
+                    await logService.log({ action: 'delete_remote', contentType: uid, syncId: record.syncId, direction: 'push', status: 'error', message: err.message });
+                  }
+                }
+
+                for (const record of diff.toDeleteLocal) {
+                  try {
+                    await deleteLocal(strapi, uid, record);
+                    await logService.log({ action: 'delete_local', contentType: uid, syncId: record.syncId, direction: 'pull', status: 'success', message: `Deleted local record ${record.syncId}` });
+                  } catch (err) {
+                    errors++;
+                    await logService.log({ action: 'delete_local', contentType: uid, syncId: record.syncId, direction: 'pull', status: 'error', message: err.message });
+                  }
+                }
               }
             }
 
             await setLastSyncTimestamp(uid, syncStartTime);
 
-            const summary = { uid, pushed, pulled, errors, hasFieldPolicies: !!fieldPolicies };
+            const summary = { uid, pushed, pulled, errors, hasFieldPolicies: !!fieldPolicies, executionStrategy };
             results.push(summary);
 
             await logService.log({
@@ -175,7 +261,7 @@ module.exports = ({ strapi }) => {
               contentType: uid,
               direction,
               status: errors > 0 ? 'partial' : 'success',
-              message: `Pushed: ${pushed}, Pulled: ${pulled}, Errors: ${errors}${fieldPolicies ? ' (with field policies)' : ''}`,
+              message: `Pushed: ${pushed}, Pulled: ${pulled}, Errors: ${errors}${fieldPolicies ? ' (with field policies)' : ''}${executionStrategy === 'hybrid_two_pass' ? ' (hybrid two-pass)' : ''}`,
               details: summary,
             });
           } catch (err) {
@@ -243,6 +329,8 @@ module.exports = ({ strapi }) => {
       const conflictStrategy = profile?.conflictStrategy || syncConfig.conflictStrategy || 'latest';
       const syncDeletions = !!(profile?.syncDeletions);
       const fields = ctConfig.fields || [];
+      const executionStrategy = profile?.executionStrategy || 'hybrid_two_pass';
+      const phases = executionStrategy === 'one_pass' ? ['all'] : ['entities', 'relations'];
 
       // Field-level policies: prefer the policies on the provided profile,
       // otherwise fall back to the active profile for the content type.
@@ -270,72 +358,81 @@ module.exports = ({ strapi }) => {
       let errors = 0;
 
       try {
-        const localRecords = await fetchLocalRecords(strapi, uid, { fields, lastSyncAt, pageSize });
-        const remoteRecords = await fetchRemoteRecords(remoteConfig, uid, { fields, lastSyncAt, pageSize });
-
-        const diff = compareRecords(localRecords, remoteRecords, { direction, conflictStrategy, syncDeletions });
+        for (const phase of phases) {
+          const phaseFields = selectFieldsForPhase(uid, fields, phase);
+          const localRecords = await fetchLocalRecords(strapi, uid, { fields: phaseFields, lastSyncAt, pageSize });
+          const remoteRecords = await fetchRemoteRecords(remoteConfig, uid, { fields: phaseFields, lastSyncAt, pageSize });
+
+          const diff = compareRecords(localRecords, remoteRecords, {
+            direction,
+            conflictStrategy,
+            syncDeletions: phase === 'relations' ? false : syncDeletions,
+          });
 
-        for (const { local } of diff.toPush) {
-          try {
-            const filteredRecord = syncProfilesService.filterFieldsByPolicy(local, fieldPolicies, 'push');
-            await applyRemote(remoteConfig, uid, filteredRecord, fields);
-            pushed++;
-          } catch (err) {
-            errors++;
-            await logService.log({ action: 'push', contentType: uid, syncId: local.syncId, direction: 'push', status: 'error', message: err.message });
+          for (const { local } of diff.toPush) {
+            try {
+              const filteredRecord = syncProfilesService.filterFieldsByPolicy(local, fieldPolicies, 'push');
+              await applyRemote(remoteConfig, uid, filteredRecord, phaseFields);
+              pushed++;
+            } catch (err) {
+              errors++;
+              await logService.log({ action: 'push', contentType: uid, syncId: local.syncId, direction: 'push', status: 'error', message: err.message });
+            }
           }
-        }
 
-        for (const { remote } of diff.toPull) {
-          try {
-            const filteredRecord = syncProfilesService.filterFieldsByPolicy(remote, fieldPolicies, 'pull');
-            await applyLocal(strapi, uid, filteredRecord, fields);
-            pulled++;
-          } catch (err) {
-            errors++;
-            await logService.log({ action: 'pull', contentType: uid, syncId: remote.syncId, direction: 'pull', status: 'error', message: err.message });
+          for (const { remote } of diff.toPull) {
+            try {
+              const filteredRecord = syncProfilesService.filterFieldsByPolicy(remote, fieldPolicies, 'pull');
+              await applyLocal(strapi, uid, filteredRecord, phaseFields);
+              pulled++;
+            } catch (err) {
+              errors++;
+              await logService.log({ action: 'pull', contentType: uid, syncId: remote.syncId, direction: 'pull', status: 'error', message: err.message });
+            }
           }
-        }
 
-        for (const record of diff.toCreateRemote) {
-          try {
-            const filteredRecord = syncProfilesService.filterFieldsByPolicy(record, fieldPolicies, 'push');
-            await applyRemote(remoteConfig, uid, filteredRecord, fields);
-            pushed++;
-          } catch (err) {
-            errors++;
-            await logService.log({ action: 'create_remote', contentType: uid, syncId: record.syncId, direction: 'push', status: 'error', message: err.message });
+          for (const record of diff.toCreateRemote) {
+            try {
+              const filteredRecord = syncProfilesService.filterFieldsByPolicy(record, fieldPolicies, 'push');
+              await applyRemote(remoteConfig, uid, filteredRecord, phaseFields);
+              pushed++;
+            } catch (err) {
+              errors++;
+              await logService.log({ action: 'create_remote', contentType: uid, syncId: record.syncId, direction: 'push', status: 'error', message: err.message });
+            }
           }
-        }
 
-        for (const record of diff.toCreateLocal) {
-          try {
-            const filteredRecord = syncProfilesService.filterFieldsByPolicy(record, fieldPolicies, 'pull');
-            await applyLocal(strapi, uid, filteredRecord, fields);
-            pulled++;
-          } catch (err) {
-            errors++;
-            await logService.log({ action: 'create_local', contentType: uid, syncId: record.syncId, direction: 'pull', status: 'error', message: err.message });
+          for (const record of diff.toCreateLocal) {
+            try {
+              const filteredRecord = syncProfilesService.filterFieldsByPolicy(record, fieldPolicies, 'pull');
+              await applyLocal(strapi, uid, filteredRecord, phaseFields);
+              pulled++;
+            } catch (err) {
+              errors++;
+              await logService.log({ action: 'create_local', contentType: uid, syncId: record.syncId, direction: 'pull', status: 'error', message: err.message });
+            }
           }
-        }
 
-        for (const record of diff.toDeleteRemote) {
-          try {
-            await deleteRemote(remoteConfig, uid, record);
-            await logService.log({ action: 'delete_remote', contentType: uid, syncId: record.syncId, direction: 'push', status: 'success', message: `Deleted remote record ${record.syncId}` });
-          } catch (err) {
-            errors++;
-            await logService.log({ action: 'delete_remote', contentType: uid, syncId: record.syncId, direction: 'push', status: 'error', message: err.message });
-          }
-        }
+          if (phase !== 'relations') {
+            for (const record of diff.toDeleteRemote) {
+              try {
+                await deleteRemote(remoteConfig, uid, record);
+                await logService.log({ action: 'delete_remote', contentType: uid, syncId: record.syncId, direction: 'push', status: 'success', message: `Deleted remote record ${record.syncId}` });
+              } catch (err) {
+                errors++;
+                await logService.log({ action: 'delete_remote', contentType: uid, syncId: record.syncId, direction: 'push', status: 'error', message: err.message });
+              }
+            }
 
-        for (const record of diff.toDeleteLocal) {
-          try {
-            await deleteLocal(strapi, uid, record);
-            await logService.log({ action: 'delete_local', contentType: uid, syncId: record.syncId, direction: 'pull', status: 'success', message: `Deleted local record ${record.syncId}` });
-          } catch (err) {
-            errors++;
-            await logService.log({ action: 'delete_local', contentType: uid, syncId: record.syncId, direction: 'pull', status: 'error', message: err.message });
+            for (const record of diff.toDeleteLocal) {
+              try {
+                await deleteLocal(strapi, uid, record);
+                await logService.log({ action: 'delete_local', contentType: uid, syncId: record.syncId, direction: 'pull', status: 'success', message: `Deleted local record ${record.syncId}` });
+              } catch (err) {
+                errors++;
+                await logService.log({ action: 'delete_local', contentType: uid, syncId: record.syncId, direction: 'pull', status: 'error', message: err.message });
+              }
+            }
           }
         }
 
@@ -347,6 +444,7 @@ module.exports = ({ strapi }) => {
           pulled,
           errors,
           hasFieldPolicies: !!fieldPolicies,
+          executionStrategy,
           profile: profile ? { id: profile.id, name: profile.name } : null,
         };
 
@@ -355,7 +453,7 @@ module.exports = ({ strapi }) => {
           contentType: uid,
           direction,
           status: errors > 0 ? 'partial' : 'success',
-          message: `Pushed: ${pushed}, Pulled: ${pulled}, Errors: ${errors}${fieldPolicies ? ' (with field policies)' : ''}`,
+          message: `Pushed: ${pushed}, Pulled: ${pulled}, Errors: ${errors}${fieldPolicies ? ' (with field policies)' : ''}${executionStrategy === 'hybrid_two_pass' ? ' (hybrid two-pass)' : ''}`,
           details: summary,
         });
 
@@ -412,6 +510,8 @@ module.exports = ({ strapi }) => {
       const conflictStrategy = profile?.conflictStrategy || syncConfig.conflictStrategy || 'latest';
       const syncDeletions = !!(profile?.syncDeletions);
       const fields = ctConfig.fields || [];
+      const phase = options.phase || 'all';
+      const phaseFields = selectFieldsForPhase(uid, fields, phase);
 
       let fieldPolicies = null;
       if (profile && !profile.isSimple && Array.isArray(profile.fieldPolicies) && profile.fieldPolicies.length > 0) {
@@ -430,8 +530,8 @@ module.exports = ({ strapi }) => {
       let pulled = 0;
       let errors = 0;
 
-      const localPageRes = await fetchLocalPage(strapi, uid, { fields, lastSyncAt, page, pageSize });
-      const remotePageRes = await fetchRemotePage(remoteConfig, uid, { fields, lastSyncAt, page, pageSize });
+      const localPageRes = await fetchLocalPage(strapi, uid, { fields: phaseFields, lastSyncAt, page, pageSize });
+      const remotePageRes = await fetchRemotePage(remoteConfig, uid, { fields: phaseFields, lastSyncAt, page, pageSize });
 
       const localRecords = localPageRes.records || [];
       const remoteRecords = remotePageRes.records || [];
@@ -449,7 +549,7 @@ module.exports = ({ strapi }) => {
       for (const { local } of diff.toPush) {
         try {
           const filtered = syncProfilesService.filterFieldsByPolicy(local, fieldPolicies, 'push');
-          await applyRemote(remoteConfig, uid, filtered, fields);
+          await applyRemote(remoteConfig, uid, filtered, phaseFields);
           pushed++;
         } catch (err) {
           errors++;
@@ -460,7 +560,7 @@ module.exports = ({ strapi }) => {
       for (const { remote } of diff.toPull) {
         try {
           const filtered = syncProfilesService.filterFieldsByPolicy(remote, fieldPolicies, 'pull');
-          await applyLocal(strapi, uid, filtered, fields);
+          await applyLocal(strapi, uid, filtered, phaseFields);
           pulled++;
         } catch (err) {
           errors++;
@@ -471,7 +571,7 @@ module.exports = ({ strapi }) => {
       for (const record of diff.toCreateRemote) {
         try {
           const filtered = syncProfilesService.filterFieldsByPolicy(record, fieldPolicies, 'push');
-          await applyRemote(remoteConfig, uid, filtered, fields);
+          await applyRemote(remoteConfig, uid, filtered, phaseFields);
           pushed++;
         } catch (err) {
           errors++;
@@ -482,7 +582,7 @@ module.exports = ({ strapi }) => {
       for (const record of diff.toCreateLocal) {
         try {
           const filtered = syncProfilesService.filterFieldsByPolicy(record, fieldPolicies, 'pull');
-          await applyLocal(strapi, uid, filtered, fields);
+          await applyLocal(strapi, uid, filtered, phaseFields);
           pulled++;
         } catch (err) {
           errors++;

package/server/src/services/workflow-notifications.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const CONTENT_TYPE_UID = 'plugin::strapi-content-sync-pro.workflow-notification';
+const STORE_KEY = 'workflow-notification-templates';
+
+const DEFAULT_TEMPLATES = [
+  {
+    sourceApp: 'web',
+    workflow: 'order',
+    event: 'order_created',
+    title: 'New order placed',
+    message: 'Order {{orderId}} placed by {{customerName}} for {{amount}}.',
+  },
+  {
+    sourceApp: 'web',
+    workflow: 'order',
+    event: 'order_paid',
+    title: 'Order payment received',
+    message: 'Payment received for order {{orderId}}.',
+  },
+  {
+    sourceApp: 'web-user-app',
+    workflow: 'purchase',
+    event: 'purchase_initiated',
+    title: 'Purchase initiated',
+    message: 'User {{userId}} initiated purchase {{purchaseId}}.',
+  },
+  {
+    sourceApp: 'web-user-app',
+    workflow: 'purchase',
+    event: 'purchase_completed',
+    title: 'Purchase completed',
+    message: 'Purchase {{purchaseId}} completed successfully for {{userId}}.',
+  },
+];
+
+module.exports = ({ strapi }) => ({
+  getStore() {
+    return strapi.store({ type: 'plugin', name: 'strapi-content-sync-pro' });
+  },
+
+  interpolate(template, payload = {}) {
+    return template.replace(/\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g, (_, key) => {
+      const value = payload[key];
+      return value === undefined || value === null ? '' : String(value);
+    });
+  },
+
+  async seedTemplates() {
+    const store = this.getStore();
+    const existing = await store.get({ key: STORE_KEY });
+
+    if (Array.isArray(existing) && existing.length > 0) {
+      return { seeded: false, total: existing.length };
+    }
+
+    await store.set({ key: STORE_KEY, value: DEFAULT_TEMPLATES });
+    return { seeded: true, total: DEFAULT_TEMPLATES.length };
+  },
+
+  async getTemplates() {
+    const store = this.getStore();
+    const templates = await store.get({ key: STORE_KEY });
+    if (Array.isArray(templates) && templates.length > 0) {
+      return templates;
+    }
+
+    await this.seedTemplates();
+    return DEFAULT_TEMPLATES;
+  },
+
+  async findTemplate({ sourceApp, workflow, event }) {
+    const templates = await this.getTemplates();
+    return templates.find((template) => (
+      template.sourceApp === sourceApp
+      && template.workflow === workflow
+      && template.event === event
+    ));
+  },
+
+  async emit(payload = {}) {
+    const { sourceApp, workflow, event, recipient, metadata } = payload;
+
+    if (!sourceApp || !workflow || !event) {
+      throw new Error('sourceApp, workflow, and event are required');
+    }
+
+    const template = await this.findTemplate({ sourceApp, workflow, event });
+    if (!template) {
+      throw new Error(`No notification template found for ${sourceApp}/${workflow}/${event}`);
+    }
+
+    const title = this.interpolate(template.title, payload);
+    const message = this.interpolate(template.message, payload);
+
+    const entry = await strapi.documents(CONTENT_TYPE_UID).create({
+      data: {
+        sourceApp,
+        workflow,
+        event,
+        title,
+        message,
+        recipient: recipient || '',
+        orderId: payload.orderId || '',
+        purchaseId: payload.purchaseId || '',
+        status: 'pending',
+        metadata: metadata || payload,
+      },
+    });
+
+    return entry;
+  },
+
+  async list({ page = 1, pageSize = 25, sourceApp, workflow, event, status } = {}) {
+    const filters = {};
+    if (sourceApp) filters.sourceApp = sourceApp;
+    if (workflow) filters.workflow = workflow;
+    if (event) filters.event = event;
+    if (status) filters.status = status;
+
+    const start = (page - 1) * pageSize;
+
+    const [entries, total] = await Promise.all([
+      strapi.documents(CONTENT_TYPE_UID).findMany({
+        filters,
+        sort: { createdAt: 'desc' },
+        limit: pageSize,
+        start,
+      }),
+      strapi.documents(CONTENT_TYPE_UID).count({ filters }),
+    ]);
+
+    return {
+      data: entries,
+      meta: {
+        pagination: {
+          page,
+          pageSize,
+          pageCount: Math.ceil(total / pageSize),
+          total,
+        },
+      },
+    };
+  },
+});