strapi-content-sync-pro 1.0.2 → 1.0.4

package/server/src/services/config.js

@@ -3,6 +3,7 @@
 const STORE_KEY = 'remote-server-config';
 
 const SENSITIVE_FIELDS = ['apiToken', 'sharedSecret'];
+const VALID_SYNC_MODES = ['paired', 'single_side'];
 
 module.exports = ({ strapi }) => {
   function getStore() {
@@ -21,11 +22,16 @@ module.exports = ({ strapi }) => {
         return null;
       }
 
+      const normalized = {
+        syncMode: 'paired',
+        ...data,
+      };
+
       if (!safe) {
-        return data;
+        return normalized;
       }
 
-      const sanitized = { ...data };
+      const sanitized = { ...normalized };
       for (const field of SENSITIVE_FIELDS) {
         if (sanitized[field]) {
           sanitized[field] = '••••••••';
@@ -59,6 +65,16 @@ module.exports = ({ strapi }) => {
       if (config.sharedSecret !== undefined) {
         merged.sharedSecret = config.sharedSecret;
       }
+      if (config.syncMode !== undefined) {
+        if (!VALID_SYNC_MODES.includes(config.syncMode)) {
+          throw new Error(`syncMode must be one of: ${VALID_SYNC_MODES.join(', ')}`);
+        }
+        merged.syncMode = config.syncMode;
+      }
+
+      if (!merged.syncMode) {
+        merged.syncMode = 'paired';
+      }
 
       await store.set({ key: STORE_KEY, value: merged });
 

package/server/src/services/index.js

@@ -12,6 +12,8 @@ const dependencyResolver = require('./dependency-resolver');
 const syncEnforcement = require('./sync-enforcement');
 const syncMedia = require('./sync-media');
 const alerts = require('./alerts');
+const syncStats = require('./sync-stats');
+const bulkTransfer = require('./bulk-transfer');
 
 module.exports = {
   ping,
@@ -26,5 +28,7 @@ module.exports = {
   syncEnforcement,
   syncMedia,
   alerts,
+  syncStats,
+  bulkTransfer,
 };
 

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

@@ -67,6 +67,8 @@ module.exports = ({ strapi }) => {
     retryOnFailure: true,
     retryAttempts: 3,
     retryDelayMs: 5000,
+    maxLogEntries: 2000,
+    maxReportEntries: 200,
     // Pagination for content-type sync fetches (local + remote). Larger pages
     // are faster but use more memory per chunk. 100 is a safe default.
     syncPageSize: 100,
@@ -75,6 +77,12 @@ module.exports = ({ strapi }) => {
   const VALID_EXECUTION_MODES = ['on_demand', 'scheduled', 'live'];
   const VALID_SCHEDULE_TYPES = ['interval', 'timeout', 'cron', 'external'];
 
+  async function getSyncMode() {
+    const configService = plugin().service('config');
+    const config = await configService.getConfig({ safe: false });
+    return config?.syncMode || 'paired';
+  }
+
   // Basic cron validator: 5 or 6 space-separated fields
   function isValidCronExpression(expr) {
     if (typeof expr !== 'string') return false;
@@ -156,6 +164,11 @@ module.exports = ({ strapi }) => {
         throw new Error(`Invalid schedule type "${executionSettings.scheduleType}". Must be one of: ${VALID_SCHEDULE_TYPES.join(', ')}`);
       }
 
+      const syncMode = await getSyncMode();
+      if (syncMode === 'single_side' && executionSettings.executionMode === 'live') {
+        throw new Error('Live execution mode is not available in single-side mode. Use on_demand or scheduled.');
+      }
+
       // Validate schedule interval (used by interval & timeout types)
       if (executionSettings.scheduleInterval !== undefined) {
         if (executionSettings.scheduleInterval < 1 || executionSettings.scheduleInterval > 1440) {
@@ -185,6 +198,11 @@ module.exports = ({ strapi }) => {
         ...executionSettings,
         updatedAt: new Date().toISOString(),
       };
+
+      if (syncMode === 'single_side' && merged.executionMode === 'live') {
+        merged.executionMode = 'on_demand';
+        merged.enabled = false;
+      }
       settings.profiles[profileId] = merged;
 
       // Calculate an advisory nextExecutionAt for scheduled mode
@@ -223,11 +241,20 @@ module.exports = ({ strapi }) => {
       const store = getStore();
       const settings = await this.getExecutionSettings();
 
-      settings.globalSettings = {
+      const next = {
         ...settings.globalSettings,
         ...globalSettings,
       };
 
+      if (next.maxLogEntries !== undefined && Number(next.maxLogEntries) < 100) {
+        throw new Error('maxLogEntries must be at least 100');
+      }
+      if (next.maxReportEntries !== undefined && Number(next.maxReportEntries) < 10) {
+        throw new Error('maxReportEntries must be at least 10');
+      }
+
+      settings.globalSettings = next;
+
       await store.set({ key: STORE_KEY, value: settings });
       return settings.globalSettings;
     },
@@ -238,8 +265,10 @@ module.exports = ({ strapi }) => {
     async executeProfile(profileId, options = {}) {
       const syncService = plugin().service('sync');
       const profilesService = plugin().service('syncProfiles');
+      const dependencyResolver = plugin().service('dependencyResolver');
       const alertsService = plugin().service('alerts');
       const logService = plugin().service('syncLog');
+      const syncStatsService = plugin().service('syncStats');
 
       const profile = await profilesService.getProfile(profileId);
       if (!profile) {
@@ -251,6 +280,11 @@ module.exports = ({ strapi }) => {
       const dependencyDepth = options.dependencyDepth ?? executionSettings.dependencyDepth ?? 1;
 
       const startTime = new Date();
+      const reportHandle = await syncStatsService.createRunReport({
+        runType: 'profile_execution',
+        trigger: executionSettings.executionMode || 'on_demand',
+        contentTypes: [profile.contentType],
+      });
 
       try {
         // Log execution start
@@ -263,6 +297,41 @@ module.exports = ({ strapi }) => {
           details: { profileId, syncDependencies, dependencyDepth },
         });
 
+        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);
+            if (!depEnabled) {
+              dependencyResults.push({
+                uid: dependencyUid,
+                profile: null,
+                skipped: true,
+                reason: 'dependency content-type not enabled for sync',
+              });
+              continue;
+            }
+
+            const dependencyProfile = await profilesService.getActiveProfileForContentType(dependencyUid);
+            const dependencyResult = await syncService.syncContentType(dependencyUid, {
+              profile: dependencyProfile,
+              syncDependencies: false,
+              dependencyDepth: 1,
+            });
+
+            dependencyResults.push({
+              uid: dependencyUid,
+              profile: dependencyProfile ? { id: dependencyProfile.id, name: dependencyProfile.name } : null,
+              result: dependencyResult,
+            });
+          }
+        }
+
         // Execute sync
         const result = await syncService.syncContentType(profile.contentType, {
           profile,
@@ -270,19 +339,39 @@ module.exports = ({ strapi }) => {
           dependencyDepth,
         });
 
+        const fullResult = {
+          ...result,
+          dependencyResults,
+        };
+
         // Update last execution time
         await this.updateLastExecution(profileId);
 
+        await syncStatsService.completeRunReport(reportHandle.reportId, {
+          status: 'success',
+          summary: fullResult,
+        });
+
+        const globalSettings = await this.getGlobalSettings();
+        await logService.applyRetention({ maxLogs: globalSettings.maxLogEntries });
+        await syncStatsService.applyRetention({ maxReports: globalSettings.maxReportEntries });
+
         // Send success alert
         await alertsService.sendAlert('sync_success', {
           profile: profile.name,
           contentType: profile.contentType,
-          result,
+          result: fullResult,
           duration: Date.now() - startTime.getTime(),
         });
 
-        return result;
+        return fullResult;
       } catch (error) {
+        await syncStatsService.completeRunReport(reportHandle.reportId, {
+          status: 'error',
+          summary: null,
+          error: error.message,
+        });
+
         // Send failure alert
         await alertsService.sendAlert('sync_failure', {
           profile: profile.name,
@@ -515,23 +604,31 @@ module.exports = ({ strapi }) => {
       const profilesService = plugin().service('syncProfiles');
       const profiles = await profilesService.getProfiles();
 
+      const syncMode = await getSyncMode();
       const status = [];
       for (const profile of profiles) {
         const execSettings = settings.profiles[profile.id] || {};
         const handle = schedulerHandles[profile.id];
+        const executionMode = syncMode === 'single_side' && execSettings.executionMode === 'live'
+          ? 'on_demand'
+          : (execSettings.executionMode || 'on_demand');
+
         status.push({
           profileId: profile.id,
           profileName: profile.name,
           contentType: profile.contentType,
-          executionMode: execSettings.executionMode || 'on_demand',
+          executionMode,
           scheduleType: execSettings.scheduleType || null,
           scheduleInterval: execSettings.scheduleInterval || null,
           cronExpression: execSettings.cronExpression || null,
-          enabled: execSettings.enabled || false,
+          enabled: syncMode === 'single_side' && execSettings.executionMode === 'live'
+            ? false
+            : (execSettings.enabled || false),
           lastExecutedAt: execSettings.lastExecutedAt || null,
           nextExecutionAt: execSettings.nextExecutionAt || null,
           isSchedulerRunning: !!handle && !handle.external,
           isExternal: !!(handle && handle.external),
+          syncMode,
         });
       }
 

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

@@ -53,4 +53,40 @@ module.exports = ({ strapi }) => ({
       },
     };
   },
+
+  async clearLogs() {
+    const existing = await strapi.documents(CONTENT_TYPE_UID).findMany({
+      fields: ['documentId'],
+      limit: 10000,
+      sort: { createdAt: 'desc' },
+    });
+
+    for (const entry of existing) {
+      if (!entry?.documentId) continue;
+      await strapi.documents(CONTENT_TYPE_UID).delete({ documentId: entry.documentId });
+    }
+
+    return { deleted: existing.length };
+  },
+
+  async applyRetention({ maxLogs = 2000 } = {}) {
+    const safeMax = Math.max(100, Number(maxLogs) || 2000);
+    const count = await strapi.documents(CONTENT_TYPE_UID).count();
+    if (count <= safeMax) return { pruned: 0, remaining: count };
+
+    const excess = count - safeMax;
+    const toDelete = await strapi.documents(CONTENT_TYPE_UID).findMany({
+      fields: ['documentId'],
+      sort: { createdAt: 'asc' },
+      limit: excess,
+      start: 0,
+    });
+
+    for (const entry of toDelete) {
+      if (!entry?.documentId) continue;
+      await strapi.documents(CONTENT_TYPE_UID).delete({ documentId: entry.documentId });
+    }
+
+    return { pruned: toDelete.length, remaining: count - toDelete.length };
+  },
 });

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,