strapi-content-sync-pro 1.0.4 → 1.0.6

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/utils/fetcher.js

@@ -12,6 +12,8 @@ async function fetchLocalPage(strapi, uid, { fields, lastSyncAt, page = 1, pageS
     start: (page - 1) * size,
     limit: size,
     sort: 'updatedAt:asc',
+    // Include relations/components so dependency links can be compared/synced.
+    populate: '*',
   };
 
   if (lastSyncAt) {
@@ -43,6 +45,11 @@ async function fetchRemotePage(remoteConfig, uid, { fields, lastSyncAt, page = 1
     });
   }
 
+  // Include relations/components so dependency links can be compared/synced.
+  // Keep field filters above for scalar fields; Strapi still returns populated
+  // relation/component payloads when `populate=*` is set.
+  url.searchParams.set('populate', '*');
+
   if (lastSyncAt) {
     url.searchParams.set('filters[updatedAt][$gt]', lastSyncAt);
   }

package/docs/production-readiness-status.md

@@ -1,34 +0,0 @@
-# Production Readiness Status — Content Sync Pro
-
-## Current Verdict
-**NO-GO (not yet fully production-ready)**
-
-## Completed
-- Implemented paired/single-side mode behavior and enforcement.
-- Implemented Stats tab + before/after run reports.
-- Implemented manual clear + retention limits for logs/reports.
-- Added production-readiness test matrix:
-  - `docs/production-readiness-test-matrix.md`
-- Added legacy environment notes copy:
-  - `docs/test-environments-setup-legacy.txt`
-
-## Smoke Checks Passed
-- `GET http://localhost:40101/api/strapi-content-sync-pro/ping` => 200
-- `GET http://localhost:4010/api/strapi-content-sync-pro/ping` => 200
-- Package test script passes (`npm run test`) — placeholder only.
-
-## Blocking Items Before GO
-1. Execute full P0 and P1 matrix scenarios in `docs/production-readiness-test-matrix.md`.
-2. Capture evidence for each case (request/response, DB/file verification, screenshots).
-3. Verify restart/recovery after plugin copy in target runtime path.
-4. Validate single-side mode with remote plugin disabled.
-5. Validate media restore scenarios after partial deletions.
-6. Confirm retention pruning under load (high log/report volume).
-
-## Required Release Gate
-- P0 cases: 100% pass
-- P1 cases: pass or accepted risk signed off
-- No open critical defects
-
-## Recommended Next Action
-Run matrix execution in order: P0 -> P1 -> P2, then update this file with final **GO/NO-GO** sign-off.