strapi-content-sync-pro 1.0.1 → 1.0.3

package/server/src/controllers/config.js

@@ -38,8 +38,50 @@ module.exports = {
       };
     }
 
-    // Step 1: Basic reachability via public ping endpoint
+    const syncMode = config.syncMode || 'paired';
+
+    // Step 1: Basic reachability
     const startTime = Date.now();
+    if (syncMode === 'single_side') {
+      try {
+        const reachRes = await fetch(`${config.baseUrl}/api`, {
+          method: 'GET',
+          headers: { Authorization: `Bearer ${config.apiToken}` },
+        });
+
+        if (reachRes.status === 401 || reachRes.status === 403) {
+          return ctx.body = {
+            data: {
+              success: false,
+              stage: 'auth',
+              message: `API token rejected by remote server (${reachRes.status}). Verify the token is valid and can read target content APIs.`,
+              latency: Date.now() - startTime,
+            },
+          };
+        }
+      } catch (err) {
+        return ctx.body = {
+          data: {
+            success: false,
+            stage: 'network',
+            message: `Cannot reach remote server in single-side mode: ${err.message}`,
+            latency: Date.now() - startTime,
+          },
+        };
+      }
+
+      return ctx.body = {
+        data: {
+          success: true,
+          stage: 'complete',
+          message: 'Connection successful in single-side mode. Remote plugin endpoints are not required; only remote content APIs and token access are validated.',
+          latency: Date.now() - startTime,
+          remoteInfo: null,
+          mode: syncMode,
+        },
+      };
+    }
+
     let pingStatus = null;
     try {
       const pingRes = await fetch(`${config.baseUrl}/api/${PLUGIN_ID}/ping`, {
@@ -69,7 +111,7 @@ module.exports = {
 
     const pingLatency = Date.now() - startTime;
 
-    // Step 2: Verify API token works against an authenticated endpoint
+    // Step 2: Verify API token works against an authenticated plugin endpoint
     let authWorks = false;
     let remoteInfo = null;
     try {
@@ -116,10 +158,11 @@ module.exports = {
         success: true,
         stage: 'complete',
         message: authWorks
-          ? 'Connection successful and API token validated'
+          ? 'Connection successful: remote plugin is reachable and API token is valid. Ensure matching sync settings (content types, active profiles, execution mode, and shared secret) on both servers before running sync.'
           : 'Reachable but API token could not be validated',
         latency: pingLatency,
         remoteInfo,
+        mode: syncMode,
       },
     };
   },
@@ -251,10 +294,10 @@ module.exports = {
       // Step 4: Optionally get remote instance ID if plugin is installed
       let remoteInstanceId = null;
       try {
-        const remoteConfigResponse = await fetch(`${baseUrl}/api/${PLUGIN_ID}/config`, {
+        const remoteConfigResponse = await fetch(`${baseUrl}/strapi-content-sync-pro/config`, {
           method: 'GET',
           headers: {
-            Authorization: `Bearer ${apiToken}`,
+            Authorization: `Bearer ${adminJwt}`,
           },
         });
 

package/server/src/controllers/index.js

@@ -12,6 +12,7 @@ const syncEnforcement = require('./sync-enforcement');
 const syncMedia = require('./sync-media');
 const alerts = require('./alerts');
 const dependencies = require('./dependencies');
+const syncStats = require('./sync-stats');
 
 module.exports = {
   ping,
@@ -26,4 +27,5 @@ module.exports = {
   syncMedia,
   alerts,
   dependencies,
+  syncStats,
 };

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

@@ -15,4 +15,10 @@ module.exports = {
 
     ctx.body = result;
   },
+
+  async clear(ctx) {
+    const service = strapi.plugin('strapi-content-sync-pro').service('syncLog');
+    const result = await service.clearLogs();
+    ctx.body = { data: result };
+  },
 };

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

@@ -111,6 +111,25 @@ module.exports = ({ strapi }) => ({
     }
   },
 
+  // ── Morph link sync (documentId-based mapping) ───────────────────────────
+
+  async getMorphLinks(ctx) {
+    try {
+      ctx.body = { data: await service(strapi).exportMorphLinks() };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  async applyMorphLinks(ctx) {
+    try {
+      const links = ctx.request.body?.links || [];
+      ctx.body = { data: await service(strapi).applyMorphLinks(links) };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
   // ── Back-compat (old flat endpoints) ──────────────────────────────────────
 
   async getSettings(ctx) {

package/server/src/controllers/sync-stats.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const PLUGIN_ID = 'strapi-content-sync-pro';
+
+module.exports = ({ strapi }) => ({
+  async getSnapshot(ctx) {
+    try {
+      const data = await strapi.plugin(PLUGIN_ID).service('syncStats').getLatestSnapshot();
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  async getReports(ctx) {
+    const { page, pageSize } = ctx.query;
+    try {
+      const data = await strapi.plugin(PLUGIN_ID).service('syncStats').getReports({
+        page: page ? parseInt(page, 10) : 1,
+        pageSize: pageSize ? parseInt(pageSize, 10) : 10,
+      });
+      ctx.body = data;
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  async clearReports(ctx) {
+    try {
+      const result = await strapi.plugin(PLUGIN_ID).service('syncStats').clearReports();
+      ctx.body = { data: result };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  async runRetention(ctx) {
+    const body = ctx.request.body || {};
+    try {
+      const syncStats = strapi.plugin(PLUGIN_ID).service('syncStats');
+      const syncLog = strapi.plugin(PLUGIN_ID).service('syncLog');
+      const reports = await syncStats.applyRetention({ maxReports: body.maxReports });
+      const logs = await syncLog.applyRetention({ maxLogs: body.maxLogs });
+      ctx.body = { data: { reports, logs } };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+
+});

package/server/src/controllers/sync.js

@@ -15,14 +15,20 @@ module.exports = {
   async receive(ctx) {
     const { body } = ctx.request;
 
-    if (!body || !body.uid || !body.syncId) {
-      return ctx.badRequest('Missing uid, data, or syncId');
+    if (!body || !body.uid || (!body.syncId && !body.documentId)) {
+      return ctx.badRequest('Missing uid, data, or documentId/syncId');
     }
 
     const syncService = strapi.plugin('strapi-content-sync-pro').service('sync');
 
     try {
-      const result = await syncService.receiveRecord(body.uid, body.data || {}, body.syncId);
+      const result = await syncService.receiveRecord(
+        body.uid,
+        body.data || {},
+        body.syncId || null,
+        !!body.delete,
+        body.documentId || null,
+      );
       ctx.body = { data: result };
     } catch (err) {
       return ctx.badRequest(err.message);

package/server/src/routes/index.js

@@ -13,6 +13,10 @@ const contentApiRoutes = [
   { method: 'GET',  path: '/enforcement/local-info',  handler: 'syncEnforcement.getLocalInfo',   config: { policies: [] } },
   { method: 'GET',  path: '/enforcement/schema/:uid', handler: 'syncEnforcement.getLocalSchema', config: { policies: [] } },
   { method: 'POST', path: '/receive',                 handler: 'sync.receive',                   config: { policies: [], auth: false, middlewares: [verifySignature] } },
+
+  // Media morph-link sync (called by the peer instance during runProfile)
+  { method: 'GET',  path: '/media-sync/morph-links',       handler: 'syncMedia.getMorphLinks',   config: { policies: [] } },
+  { method: 'POST', path: '/media-sync/morph-links/apply', handler: 'syncMedia.applyMorphLinks', config: { policies: [] } },
 ];
 
 const adminRoutes = [
@@ -35,6 +39,13 @@ const adminRoutes = [
   // Logs
   { method: 'GET', path: '/logs', handler: 'syncLog.find', config: { policies: [] } },
 
+  // Stats and retention
+  { method: 'GET',  path: '/stats/snapshot',  handler: 'syncStats.getSnapshot',  config: { policies: [] } },
+  { method: 'GET',  path: '/stats/reports',   handler: 'syncStats.getReports',   config: { policies: [] } },
+  { method: 'POST', path: '/stats/reports/clear', handler: 'syncStats.clearReports', config: { policies: [] } },
+  { method: 'POST', path: '/stats/retention/run', handler: 'syncStats.runRetention', config: { policies: [] } },
+  { method: 'POST', path: '/logs/clear', handler: 'syncLog.clear', config: { policies: [] } },
+
   // Sync Profiles
   { method: 'GET',    path: '/sync-profiles',                          handler: 'syncProfiles.find',                    config: { policies: [] } },
   { method: 'GET',    path: '/sync-profiles/:id',                      handler: 'syncProfiles.findOne',                 config: { policies: [] } },
@@ -81,6 +92,8 @@ const adminRoutes = [
   { method: 'POST',   path: '/media-sync/profiles/:id/activate', handler: 'syncMedia.activateProfile',    config: { policies: [] } },
   { method: 'POST',   path: '/media-sync/profiles/:id/run',     handler: 'syncMedia.runProfile',          config: { policies: [] } },
   { method: 'POST',   path: '/media-sync/run-active',           handler: 'syncMedia.runActiveProfiles',   config: { policies: [] } },
+  { method: 'GET',    path: '/media-sync/morph-links',          handler: 'syncMedia.getMorphLinks',       config: { policies: [] } },
+  { method: 'POST',   path: '/media-sync/morph-links/apply',    handler: 'syncMedia.applyMorphLinks',     config: { policies: [] } },
   { method: 'GET',    path: '/media-sync/global-settings',       handler: 'syncMedia.getGlobalSettings',  config: { policies: [] } },
   { method: 'PUT',    path: '/media-sync/global-settings',       handler: 'syncMedia.updateGlobalSettings', config: { policies: [] } },
   { method: 'GET',    path: '/media-sync/defaults',              handler: 'syncMedia.getDefaults',         config: { policies: [] } },

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,7 @@ const dependencyResolver = require('./dependency-resolver');
 const syncEnforcement = require('./sync-enforcement');
 const syncMedia = require('./sync-media');
 const alerts = require('./alerts');
+const syncStats = require('./sync-stats');
 
 module.exports = {
   ping,
@@ -26,5 +27,6 @@ module.exports = {
   syncEnforcement,
   syncMedia,
   alerts,
+  syncStats,
 };
 

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 };
+  },
 });