strapi-content-sync-pro 1.0.5 → 1.0.6

package/server/src/services/bulk-transfer.js

@@ -140,6 +140,49 @@ module.exports = ({ strapi }) => {
     return out;
   }
 
+  function orderByDependencies(uids) {
+    const depResolver = plugin().service('dependencyResolver');
+    const uidSet = new Set(uids);
+    const inDegree = new Map();
+    const adjacency = new Map();
+
+    uids.forEach((uid) => {
+      inDegree.set(uid, 0);
+      adjacency.set(uid, []);
+    });
+
+    for (const uid of uids) {
+      try {
+        const rels = depResolver.analyzeContentType(uid)?.relations || [];
+        for (const rel of rels) {
+          const depUid = rel.target;
+          if (!uidSet.has(depUid) || depUid === uid) continue;
+          adjacency.get(depUid).push(uid);
+          inDegree.set(uid, (inDegree.get(uid) || 0) + 1);
+        }
+      } catch (_) {
+        // Ignore bad schema and keep fallback order.
+      }
+    }
+
+    const queue = uids.filter((uid) => (inDegree.get(uid) || 0) === 0);
+    const ordered = [];
+    while (queue.length > 0) {
+      const uid = queue.shift();
+      ordered.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);
+      }
+    }
+
+    for (const uid of uids) {
+      if (!ordered.includes(uid)) ordered.push(uid);
+    }
+    return ordered;
+  }
+
   function listMediaProfilesToRun() {
     // Use the media service's own active-profile semantics by delegating
     // to runActiveProfiles at execute time; here we just need chunk labels.
@@ -153,7 +196,8 @@ module.exports = ({ strapi }) => {
     const chunks = [];
 
     if (scopes.content) {
-      for (const uid of listSyncableContentTypeUids()) {
+      const orderedContentTypes = orderByDependencies(listSyncableContentTypeUids());
+      for (const uid of orderedContentTypes) {
         chunks.push({ kind: 'content', uid, label: uid });
       }
     }

package/server/src/services/dependency-resolver.js

@@ -195,6 +195,43 @@ module.exports = ({ strapi }) => {
       return order;
     },
 
+    /**
+     * Get constrained dependency targets for a content type under one-pass rules:
+     *   - depth fixed to 1
+     *   - only direct owner-side relation targets (no mappedBy / inversedBy)
+     *   - only targets in sync scope (scopeUids set)
+     * Returns array of { uid, field, relation } objects.
+     */
+    getConstrainedDependencyTargets(uid, scopeUids = new Set()) {
+      const analysis = this.analyzeContentType(uid);
+      const results = [];
+
+      for (const rel of analysis.relations) {
+        // Owner/declaring side only: skip inverse and mapped-by sides
+        if (rel.mappedBy || rel.inversedBy) continue;
+        // Skip self-references
+        if (rel.target === uid) continue;
+        // Skip targets not in sync scope
+        if (scopeUids.size > 0 && !scopeUids.has(rel.target)) continue;
+        // Skip plugin-internal types unless users-permissions
+        if (rel.target.startsWith('plugin::') && !rel.target.startsWith('plugin::users-permissions')) continue;
+
+        results.push({
+          uid: rel.target,
+          field: rel.field,
+          relation: rel.relation,
+        });
+      }
+
+      // Deduplicate by target uid (keep first occurrence)
+      const seen = new Set();
+      return results.filter((r) => {
+        if (seen.has(r.uid)) return false;
+        seen.add(r.uid);
+        return true;
+      });
+    },
+
     /**
      * Extract related entity IDs from a record for dependency syncing
      */

package/server/src/services/sync-execution.js

@@ -277,7 +277,8 @@ module.exports = ({ strapi }) => {
 
       const executionSettings = await this.getProfileExecutionSettings(profileId);
       const syncDependencies = options.syncDependencies ?? executionSettings.syncDependencies;
-      const dependencyDepth = options.dependencyDepth ?? executionSettings.dependencyDepth ?? 1;
+      // dependencyDepth is always 1 per strategy constraints regardless of stored setting
+      const dependencyDepth = 1;
 
       const startTime = new Date();
       const reportHandle = await syncStatsService.createRunReport({
@@ -299,14 +300,25 @@ module.exports = ({ strapi }) => {
 
         const dependencyResults = [];
         if (syncDependencies) {
-          const dependencyOrder = dependencyResolver
-            .getSyncOrder(profile.contentType, dependencyDepth)
-            .filter((uid) => uid !== profile.contentType && uid.startsWith('api::') && !!strapi.contentTypes[uid]);
-
-          for (const dependencyUid of dependencyOrder) {
-            const syncConfigService = plugin().service('syncConfig');
-            const syncConfig = await syncConfigService.getSyncConfig();
-            const depEnabled = (syncConfig.contentTypes || []).some((ct) => ct.uid === dependencyUid && ct.enabled);
+          // Constrained dependency expansion:
+          //   - depth fixed to 1
+          //   - owner/declaring side only (no mappedBy/inversedBy traversal)
+          //   - only targets in sync scope (enabled content types)
+          const syncConfigService = plugin().service('syncConfig');
+          const syncConfig = await syncConfigService.getSyncConfig();
+          const scopeUids = new Set(
+            (syncConfig.contentTypes || [])
+              .filter((ct) => ct.enabled && ct.uid !== profile.contentType)
+              .map((ct) => ct.uid)
+          );
+
+          const constrainedTargets = dependencyResolver.getConstrainedDependencyTargets(
+            profile.contentType,
+            scopeUids
+          );
+
+          for (const { uid: dependencyUid } of constrainedTargets) {
+            const depEnabled = scopeUids.has(dependencyUid);
             if (!depEnabled) {
               dependencyResults.push({
                 uid: dependencyUid,

package/server/src/services/sync-profiles.js

@@ -37,6 +37,7 @@ module.exports = ({ strapi }) => {
 
   const VALID_DIRECTIONS = ['push', 'pull', 'both', 'none'];
   const VALID_CONFLICT_STRATEGIES = ['latest', 'local_wins', 'remote_wins'];
+  const VALID_EXECUTION_STRATEGIES = ['hybrid_two_pass', 'one_pass'];
 
   async function getSyncMode() {
     const configService = strapi.plugin('strapi-content-sync-pro').service('config');
@@ -70,24 +71,33 @@ module.exports = ({ strapi }) => {
       const data = await store.get({ key: STORE_KEY });
       const profiles = data || [];
       const syncMode = await getSyncMode();
-      if (syncMode !== 'single_side') return profiles;
 
       let changed = false;
       const normalized = profiles.map((p) => {
-        if (p.direction === 'pull') return p;
-        changed = true;
-        return {
-          ...p,
-          direction: 'pull',
-          syncDeletions: !!p.syncDeletions,
-          fieldPolicies: Array.isArray(p.fieldPolicies)
-            ? p.fieldPolicies.map((fp) => ({
-                ...fp,
-                direction: fp.direction === 'none' ? 'none' : 'pull',
-              }))
-            : p.fieldPolicies,
-          updatedAt: new Date().toISOString(),
-        };
+        let next = p;
+
+        if (!next.executionStrategy) {
+          changed = true;
+          next = { ...next, executionStrategy: 'hybrid_two_pass' };
+        }
+
+        if (syncMode === 'single_side' && next.direction !== 'pull') {
+          changed = true;
+          next = {
+            ...next,
+            direction: 'pull',
+            syncDeletions: !!next.syncDeletions,
+            fieldPolicies: Array.isArray(next.fieldPolicies)
+              ? next.fieldPolicies.map((fp) => ({
+                  ...fp,
+                  direction: fp.direction === 'none' ? 'none' : 'pull',
+                }))
+              : next.fieldPolicies,
+            updatedAt: new Date().toISOString(),
+          };
+        }
+
+        return next;
       });
 
       if (changed) {
@@ -222,12 +232,17 @@ module.exports = ({ strapi }) => {
         }
       }
 
+      if (profileData.executionStrategy && !VALID_EXECUTION_STRATEGIES.includes(profileData.executionStrategy)) {
+        throw new Error(`Invalid execution strategy "${profileData.executionStrategy}"`);
+      }
+
       const newProfile = {
         id: generateId(),
         name: profileData.name,
         contentType: profileData.contentType,
         direction: profileData.direction || 'both',
         conflictStrategy: profileData.conflictStrategy || 'latest',
+        executionStrategy: profileData.executionStrategy || 'hybrid_two_pass',
         syncDeletions: !!profileData.syncDeletions,
         isActive: profileData.isActive || false,
         isSimple: profileData.isSimple !== false, // Default to simple mode
@@ -299,6 +314,10 @@ module.exports = ({ strapi }) => {
         }
       }
 
+      if (updates.executionStrategy && !VALID_EXECUTION_STRATEGIES.includes(updates.executionStrategy)) {
+        throw new Error(`Invalid execution strategy "${updates.executionStrategy}"`);
+      }
+
       // If setting this profile as active, deactivate others for same content type
       if (updates.isActive) {
         const contentType = updates.contentType || profiles[index].contentType;
@@ -392,6 +411,7 @@ module.exports = ({ strapi }) => {
       return this.createProfile({
         ...presetConfig,
         contentType: contentTypeUid,
+        executionStrategy: 'hybrid_two_pass',
         syncDeletions: false,
         isSimple: true,
         isActive: false,
@@ -428,6 +448,7 @@ module.exports = ({ strapi }) => {
       return {
         direction: activeProfile.direction,
         conflictStrategy: activeProfile.conflictStrategy,
+        executionStrategy: activeProfile.executionStrategy || 'hybrid_two_pass',
         fieldPolicies: activeProfile.isSimple ? null : await this.getFieldPoliciesForContentType(contentTypeUid),
       };
     },