strapi-content-sync-pro 1.0.1 → 1.0.3

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

@@ -155,6 +155,31 @@ module.exports = ({ strapi }) => {
     return strapi.plugin(PLUGIN_NAME);
   }
 
+  // ---------------------------------------------------------------------------
+  // Morph join-table resolution
+  // ---------------------------------------------------------------------------
+  // Strapi's upload plugin stores polymorphic file↔entity links in a morph
+  // join table whose name differs between Strapi versions (e.g.
+  // `files_related_morphs` on some v4 builds vs `files_related_mph` on
+  // Strapi v5). Resolve it from ORM metadata so the plugin works everywhere.
+  let _morphTableCache = null;
+  function resolveMorphTable() {
+    if (_morphTableCache) return _morphTableCache;
+    const candidates = [];
+    try {
+      const meta = strapi.db?.metadata?.get?.('plugin::upload.file');
+      const attr = meta?.attributes?.related;
+      if (attr?.joinTable?.name) candidates.push(attr.joinTable.name);
+      if (attr?.pivotTable) candidates.push(attr.pivotTable);
+    } catch {
+      // ignore — fall back to known names below
+    }
+    // Known historical defaults, most-recent first.
+    candidates.push('files_related_mph', 'files_related_morphs');
+    _morphTableCache = candidates.find((n) => !!n) || 'files_related_mph';
+    return _morphTableCache;
+  }
+
   // ---------------------------------------------------------------------------
   // Profile CRUD
   // ---------------------------------------------------------------------------
@@ -408,6 +433,170 @@ module.exports = ({ strapi }) => {
     return 'needs_bytes';
   }
 
+  async function exportMorphLinks() {
+    const morphTable = resolveMorphTable();
+    const rows = await strapi.db.connection(morphTable).select('*');
+    const fileCache = new Map();
+    const relatedDocCache = new Map();
+    const out = [];
+
+    for (const row of rows) {
+      const fileId = Number(row.file_id);
+      if (!fileCache.has(fileId)) {
+        const file = await strapi.db.query('plugin::upload.file').findOne({
+          where: { id: fileId },
+          select: ['id', 'documentId'],
+        });
+        fileCache.set(fileId, file || null);
+      }
+
+      const file = fileCache.get(fileId);
+      if (!file?.documentId) continue;
+
+      const relatedType = row.related_type;
+      const relatedId = Number(row.related_id);
+      const relatedKey = `${relatedType}:${relatedId}`;
+
+      if (!relatedDocCache.has(relatedKey)) {
+        try {
+          const entity = await strapi.db.query(relatedType).findOne({
+            where: { id: relatedId },
+            select: ['id', 'documentId'],
+          });
+          relatedDocCache.set(relatedKey, entity?.documentId || null);
+        } catch {
+          relatedDocCache.set(relatedKey, null);
+        }
+      }
+
+      const relatedDocumentId = relatedDocCache.get(relatedKey);
+      if (!relatedDocumentId) continue;
+
+      out.push({
+        fileDocumentId: file.documentId,
+        relatedType,
+        relatedDocumentId,
+        field: row.field || null,
+        order: row.order || 1,
+      });
+    }
+
+    return out;
+  }
+
+  async function applyMorphLinks(links = []) {
+    const applied = [];
+    const skipped = [];
+    const errors = [];
+
+    for (const link of links) {
+      try {
+        if (!link?.fileDocumentId || !link?.relatedType || !link?.relatedDocumentId) {
+          skipped.push({ link, reason: 'missing required documentId fields' });
+          continue;
+        }
+
+        const file = await strapi.db.query('plugin::upload.file').findOne({
+          where: { documentId: link.fileDocumentId },
+          select: ['id', 'documentId'],
+        });
+        if (!file?.id) {
+          skipped.push({ link, reason: 'file documentId not found locally' });
+          continue;
+        }
+
+        let related = null;
+        try {
+          related = await strapi.db.query(link.relatedType).findOne({
+            where: { documentId: link.relatedDocumentId },
+            select: ['id', 'documentId'],
+          });
+        } catch {
+          skipped.push({ link, reason: 'related type not queryable locally' });
+          continue;
+        }
+
+        if (!related?.id) {
+          skipped.push({ link, reason: 'related documentId not found locally' });
+          continue;
+        }
+
+        const morphTable = resolveMorphTable();
+        let existsQ = strapi.db.connection(morphTable)
+          .where('file_id', file.id)
+          .andWhere('related_id', related.id)
+          .andWhere('related_type', link.relatedType);
+
+        if (link.field) existsQ = existsQ.andWhere('field', link.field);
+        else existsQ = existsQ.whereNull('field');
+
+        const existing = await existsQ.first();
+        if (existing) {
+          skipped.push({ link, reason: 'morph link already exists' });
+          continue;
+        }
+
+        await strapi.db.connection(morphTable).insert({
+          file_id: file.id,
+          related_id: related.id,
+          related_type: link.relatedType,
+          field: link.field || null,
+          order: link.order || 1,
+        });
+
+        applied.push(link);
+      } catch (err) {
+        errors.push({ link, error: err.message });
+      }
+    }
+
+    return {
+      total: links.length,
+      applied: applied.length,
+      skipped: skipped.length,
+      errors,
+    };
+  }
+
+  async function fetchRemoteMorphLinks(remoteConfig) {
+    const url = new URL('/api/strapi-content-sync-pro/media-sync/morph-links', remoteConfig.baseUrl);
+    const res = await fetch(url.toString(), {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${remoteConfig.apiToken}`,
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!res.ok) {
+      const body = await safeReadBody(res);
+      throw new Error(`Remote morph-links fetch failed (${res.status}): ${body}`);
+    }
+
+    const json = await res.json();
+    return json?.data || [];
+  }
+
+  async function applyRemoteMorphLinks(remoteConfig, links = []) {
+    const url = new URL('/api/strapi-content-sync-pro/media-sync/morph-links/apply', remoteConfig.baseUrl);
+    const res = await fetch(url.toString(), {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${remoteConfig.apiToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ links }),
+    });
+
+    if (!res.ok) {
+      const body = await safeReadBody(res);
+      throw new Error(`Remote morph-links apply failed (${res.status}): ${body}`);
+    }
+
+    const json = await res.json();
+    return json?.data || { total: links.length, applied: 0, skipped: 0, errors: [] };
+  }
+
   // ---------------------------------------------------------------------------
   // URL strategy
   // ---------------------------------------------------------------------------
@@ -594,7 +783,7 @@ module.exports = ({ strapi }) => {
     const remoteConfig = await configService.getConfig({ safe: false });
     if (!remoteConfig?.baseUrl) throw new Error('Remote server not configured');
 
-    const totals = { pushed: 0, pulled: 0, skipped: 0, dbRowsUpdated: 0, errors: [] };
+    const totals = { pushed: 0, pulled: 0, skipped: 0, dbRowsUpdated: 0, morphLinksApplied: 0, morphLinksSkipped: 0, errors: [] };
     const started = Date.now();
 
     const localIndex = new Map();
@@ -631,6 +820,22 @@ module.exports = ({ strapi }) => {
       }
     }
 
+    if (profile.syncDbRows) {
+      try {
+        if (settings.direction === 'pull' || settings.direction === 'both') {
+          const remoteLinks = await fetchRemoteMorphLinks(remoteConfig);
+          const applyResult = await applyMorphLinks(remoteLinks);
+          totals.morphLinksApplied += applyResult.applied || 0;
+          totals.morphLinksSkipped += applyResult.skipped || 0;
+          if (Array.isArray(applyResult.errors) && applyResult.errors.length > 0) {
+            totals.errors.push(...applyResult.errors.map((e) => ({ name: 'morph_pull', error: e.error || 'morph apply error' })));
+          }
+        }
+      } catch (err) {
+        totals.errors.push({ name: 'morph_pull', error: err.message });
+      }
+    }
+
     // PUSH: local -> remote
     if (settings.direction === 'push' || settings.direction === 'both') {
       const remoteIndex = new Map();
@@ -666,6 +871,20 @@ module.exports = ({ strapi }) => {
       }
     }
 
+    if (profile.syncDbRows && (settings.direction === 'push' || settings.direction === 'both')) {
+      try {
+        const localLinks = await exportMorphLinks();
+        const applyRemoteResult = await applyRemoteMorphLinks(remoteConfig, localLinks);
+        totals.morphLinksApplied += applyRemoteResult.applied || 0;
+        totals.morphLinksSkipped += applyRemoteResult.skipped || 0;
+        if (Array.isArray(applyRemoteResult.errors) && applyRemoteResult.errors.length > 0) {
+          totals.errors.push(...applyRemoteResult.errors.map((e) => ({ name: 'morph_push', error: e.error || 'remote morph apply error' })));
+        }
+      } catch (err) {
+        totals.errors.push({ name: 'morph_push', error: err.message });
+      }
+    }
+
     const summary = {
       strategy: 'url',
       profileId: profile.id,
@@ -900,6 +1119,10 @@ module.exports = ({ strapi }) => {
     runProfile,
     runActiveProfiles,
 
+    // Morph link APIs (documentId-based)
+    exportMorphLinks,
+    applyMorphLinks,
+
     // Schedulers
     initializeSchedulers,
     stopAllSchedulers,

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

@@ -38,6 +38,29 @@ module.exports = ({ strapi }) => {
   const VALID_DIRECTIONS = ['push', 'pull', 'both', 'none'];
   const VALID_CONFLICT_STRATEGIES = ['latest', 'local_wins', 'remote_wins'];
 
+  async function getSyncMode() {
+    const configService = strapi.plugin('strapi-content-sync-pro').service('config');
+    const config = await configService.getConfig({ safe: false });
+    return config?.syncMode || 'paired';
+  }
+
+  function normalizeProfileForMode(profile, syncMode) {
+    if (syncMode !== 'single_side') return profile;
+
+    const next = { ...profile };
+    next.direction = 'pull';
+
+    if (!next.isSimple && Array.isArray(next.fieldPolicies)) {
+      next.fieldPolicies = next.fieldPolicies.map((fp) => {
+        if (fp.direction === 'push') return { ...fp, direction: 'pull' };
+        if (fp.direction === 'both') return { ...fp, direction: 'pull' };
+        return fp;
+      });
+    }
+
+    return next;
+  }
+
   return {
     /**
      * Get all sync profiles
@@ -45,7 +68,33 @@ module.exports = ({ strapi }) => {
     async getProfiles() {
       const store = getStore();
       const data = await store.get({ key: STORE_KEY });
-      return data || [];
+      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(),
+        };
+      });
+
+      if (changed) {
+        await store.set({ key: STORE_KEY, value: normalized });
+      }
+
+      return normalized;
     },
 
     /**
@@ -53,7 +102,10 @@ module.exports = ({ strapi }) => {
      */
     async getProfile(id) {
       const profiles = await this.getProfiles();
-      return profiles.find((p) => p.id === id) || null;
+      const profile = profiles.find((p) => p.id === id) || null;
+      if (!profile) return null;
+      const syncMode = await getSyncMode();
+      return normalizeProfileForMode(profile, syncMode);
     },
 
     /**
@@ -61,7 +113,11 @@ module.exports = ({ strapi }) => {
      */
     async getActiveProfileForContentType(contentTypeUid) {
       const profiles = await this.getProfiles();
-      return profiles.find((p) => p.contentType === contentTypeUid && p.isActive) || null;
+      const active = profiles.find((p) => p.contentType === contentTypeUid && p.isActive) || null;
+      if (!active) return null;
+
+      const syncMode = await getSyncMode();
+      return normalizeProfileForMode(active, syncMode);
     },
 
     /**
@@ -69,7 +125,10 @@ module.exports = ({ strapi }) => {
      */
     async getProfilesForContentType(contentTypeUid) {
       const profiles = await this.getProfiles();
-      return profiles.filter((p) => p.contentType === contentTypeUid);
+      const syncMode = await getSyncMode();
+      return profiles
+        .filter((p) => p.contentType === contentTypeUid)
+        .map((p) => normalizeProfileForMode(p, syncMode));
     },
 
     /**
@@ -91,6 +150,7 @@ module.exports = ({ strapi }) => {
           contentType: contentTypeUid,
           direction: 'push',
           conflictStrategy: 'local_wins',
+          syncDeletions: false,
           isActive: false,
           isSimple: true,
           fieldPolicies: [],
@@ -100,6 +160,7 @@ module.exports = ({ strapi }) => {
           contentType: contentTypeUid,
           direction: 'pull',
           conflictStrategy: 'remote_wins',
+          syncDeletions: false,
           isActive: false,
           isSimple: true,
           fieldPolicies: [],
@@ -109,6 +170,7 @@ module.exports = ({ strapi }) => {
           contentType: contentTypeUid,
           direction: 'both',
           conflictStrategy: 'latest',
+          syncDeletions: false,
           isActive: true, // Default active profile
           isSimple: true,
           fieldPolicies: [],
@@ -166,6 +228,7 @@ module.exports = ({ strapi }) => {
         contentType: profileData.contentType,
         direction: profileData.direction || 'both',
         conflictStrategy: profileData.conflictStrategy || 'latest',
+        syncDeletions: !!profileData.syncDeletions,
         isActive: profileData.isActive || false,
         isSimple: profileData.isSimple !== false, // Default to simple mode
         fieldPolicies: (profileData.fieldPolicies || []).map((fp) => ({
@@ -176,6 +239,17 @@ module.exports = ({ strapi }) => {
         updatedAt: new Date().toISOString(),
       };
 
+      const syncMode = await getSyncMode();
+      if (syncMode === 'single_side') {
+        newProfile.direction = 'pull';
+        if (!newProfile.isSimple && Array.isArray(newProfile.fieldPolicies)) {
+          newProfile.fieldPolicies = newProfile.fieldPolicies.map((fp) => ({
+            ...fp,
+            direction: fp.direction === 'none' ? 'none' : 'pull',
+          }));
+        }
+      }
+
       // If this profile is set as active, deactivate others for same content type
       if (newProfile.isActive) {
         profiles.forEach((p) => {
@@ -238,11 +312,17 @@ module.exports = ({ strapi }) => {
       const updatedProfile = {
         ...profiles[index],
         ...updates,
+        syncDeletions: updates.syncDeletions !== undefined ? !!updates.syncDeletions : profiles[index].syncDeletions,
         id: profiles[index].id, // prevent id change
         createdAt: profiles[index].createdAt, // preserve creation date
         updatedAt: new Date().toISOString(),
       };
 
+      const syncMode = await getSyncMode();
+      if (syncMode === 'single_side') {
+        updatedProfile.direction = 'pull';
+      }
+
       if (updates.fieldPolicies) {
         updatedProfile.fieldPolicies = updates.fieldPolicies.map((fp) => ({
           field: fp.field,
@@ -250,6 +330,13 @@ module.exports = ({ strapi }) => {
         }));
       }
 
+      if (syncMode === 'single_side' && !updatedProfile.isSimple && Array.isArray(updatedProfile.fieldPolicies)) {
+        updatedProfile.fieldPolicies = updatedProfile.fieldPolicies.map((fp) => ({
+          ...fp,
+          direction: fp.direction === 'none' ? 'none' : 'pull',
+        }));
+      }
+
       profiles[index] = updatedProfile;
       await store.set({ key: STORE_KEY, value: profiles });
 
@@ -305,6 +392,7 @@ module.exports = ({ strapi }) => {
       return this.createProfile({
         ...presetConfig,
         contentType: contentTypeUid,
+        syncDeletions: false,
         isSimple: true,
         isActive: false,
         fieldPolicies: [],