strapi-content-sync-pro 1.0.0

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

@@ -0,0 +1,323 @@
+'use strict';
+
+const PLUGIN_ID = 'strapi-content-sync-pro';
+
+module.exports = ({ strapi }) => ({
+  /**
+   * GET /enforcement/settings
+   * Get enforcement settings
+   */
+  async getSettings(ctx) {
+    try {
+      const settings = await strapi.plugin(PLUGIN_ID).service('syncEnforcement').getSettings();
+      ctx.body = { data: settings };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  /**
+   * PUT /enforcement/settings
+   * Update enforcement settings
+   */
+  async updateSettings(ctx) {
+    const body = ctx.request.body;
+    try {
+      const settings = await strapi.plugin(PLUGIN_ID).service('syncEnforcement').updateSettings(body);
+      ctx.body = { data: settings };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  /**
+   * GET /enforcement/local-info
+   * Get local version and schema info
+   */
+  async getLocalInfo(ctx) {
+    try {
+      const service = strapi.plugin(PLUGIN_ID).service('syncEnforcement');
+      const versionInfo = service.getLocalVersionInfo();
+      ctx.body = { data: versionInfo };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  /**
+   * GET /enforcement/remote-info
+   * Get remote server info for connection test
+   */
+  async getRemoteInfo(ctx) {
+    try {
+      const configService = strapi.plugin(PLUGIN_ID).service('config');
+      const config = await configService.getConfig({ safe: false });
+
+      if (!config || !config.baseUrl) {
+        return ctx.throw(400, 'Remote server not configured');
+      }
+
+      const url = `${config.baseUrl}/api/${PLUGIN_ID}/enforcement/local-info`;
+      const response = await fetch(url, {
+        headers: {
+          Authorization: `Bearer ${config.apiToken}`,
+        },
+      });
+
+      if (!response.ok) {
+        let errorDetail = '';
+        try {
+          const errorBody = await response.json();
+          errorDetail = errorBody?.error?.message || JSON.stringify(errorBody);
+        } catch {
+          errorDetail = await response.text();
+        }
+        return ctx.throw(response.status, `Remote server returned ${response.status}: ${errorDetail}`);
+      }
+
+      const data = await response.json();
+      ctx.body = { data: data.data };
+    } catch (err) {
+      if (err.status) {
+        throw err; // Re-throw Koa errors
+      }
+      ctx.throw(500, err.message || 'Failed to get remote info');
+    }
+  },
+
+  /**
+   * GET /enforcement/check/:type
+   * Run individual diagnostic check (schema, version, time)
+   */
+  async runDiagnosticCheck(ctx) {
+    const { type } = ctx.params;
+    const validTypes = ['schema', 'version', 'time'];
+
+    if (!validTypes.includes(type)) {
+      return ctx.throw(400, `Invalid check type. Must be one of: ${validTypes.join(', ')}`);
+    }
+
+    try {
+      const configService = strapi.plugin(PLUGIN_ID).service('config');
+      const enforcementService = strapi.plugin(PLUGIN_ID).service('syncEnforcement');
+      const syncConfigService = strapi.plugin(PLUGIN_ID).service('syncConfig');
+
+      const config = await configService.getConfig({ safe: false });
+
+      if (!config || !config.baseUrl) {
+        return ctx.body = {
+          data: {
+            passed: false,
+            error: 'Remote server not configured',
+          },
+        };
+      }
+
+      // Get remote info
+      let remoteInfo;
+      try {
+        const response = await fetch(`${config.baseUrl}/api/${PLUGIN_ID}/enforcement/local-info`, {
+          headers: {
+            Authorization: `Bearer ${config.apiToken}`,
+          },
+        });
+
+        if (!response.ok) {
+          return ctx.body = {
+            data: {
+              passed: false,
+              error: `Cannot reach remote server (${response.status})`,
+            },
+          };
+        }
+
+        remoteInfo = (await response.json()).data;
+      } catch (err) {
+        return ctx.body = {
+          data: {
+            passed: false,
+            error: `Connection failed: ${err.message}`,
+          },
+        };
+      }
+
+      const localInfo = enforcementService.getLocalVersionInfo();
+      const settings = await enforcementService.getSettings();
+
+      let result = { passed: true, details: {} };
+
+      switch (type) {
+        case 'version': {
+          const versionResult = enforcementService.compareVersions(
+            localInfo.strapiVersion,
+            remoteInfo.strapiVersion,
+            settings.allowedVersionDrift
+          );
+          result = {
+            passed: versionResult.compatible,
+            details: {
+              localVersion: localInfo.strapiVersion,
+              remoteVersion: remoteInfo.strapiVersion,
+              driftLevel: versionResult.driftLevel,
+              message: versionResult.message,
+            },
+          };
+          break;
+        }
+
+        case 'time': {
+          const localTime = new Date();
+          const remoteTime = new Date(remoteInfo.serverTime);
+          const driftMs = Math.abs(localTime - remoteTime);
+          const passed = driftMs <= settings.maxTimeDriftMs;
+
+          result = {
+            passed,
+            details: {
+              localTime: localTime.toISOString(),
+              remoteTime: remoteInfo.serverTime,
+              driftMs,
+              maxAllowed: settings.maxTimeDriftMs,
+              message: passed 
+                ? `Time drift of ${driftMs}ms is within allowed limit`
+                : `Time drift of ${driftMs}ms exceeds limit of ${settings.maxTimeDriftMs}ms`,
+            },
+          };
+          break;
+        }
+
+        case 'schema': {
+          const syncConfig = await syncConfigService.getSyncConfig();
+          const enabledTypes = (syncConfig.contentTypes || [])
+            .filter((ct) => ct.enabled !== false)
+            .map((ct) => ct.uid);
+          const mismatches = [];
+
+          if (enabledTypes.length === 0) {
+            result = {
+              passed: true,
+              details: {
+                checkedTypes: [],
+                mismatches: [],
+                matchMode: settings.schemaMatchMode,
+                message: 'No content types enabled for sync',
+              },
+            };
+            break;
+          }
+
+          for (const uid of enabledTypes) {
+            try {
+              // Get remote schema
+              const schemaResponse = await fetch(
+                `${config.baseUrl}/api/${PLUGIN_ID}/enforcement/schema/${encodeURIComponent(uid)}`,
+                {
+                  headers: {
+                    Authorization: `Bearer ${config.apiToken}`,
+                  },
+                }
+              );
+
+              if (!schemaResponse.ok) {
+                mismatches.push({
+                  type: uid,
+                  reason: `Not found on remote (${schemaResponse.status})`,
+                });
+                continue;
+              }
+
+              const remoteSchema = (await schemaResponse.json()).data?.schema;
+              const localSchema = enforcementService.getLocalSchema(uid);
+
+              if (!localSchema) {
+                mismatches.push({
+                  type: uid,
+                  reason: 'Not found locally',
+                });
+                continue;
+              }
+
+              // Compare schemas
+              const comparison = enforcementService.compareSchemas(localSchema, remoteSchema, settings.schemaMatchMode);
+              if (!comparison.compatible) {
+                mismatches.push({
+                  type: uid,
+                  reason: comparison.differences?.join(', ') || 'Schema mismatch',
+                });
+              }
+            } catch (err) {
+              mismatches.push({
+                type: uid,
+                reason: err.message,
+              });
+            }
+          }
+
+          result = {
+            passed: mismatches.length === 0,
+            details: {
+              checkedTypes: enabledTypes,
+              mismatches,
+              matchMode: settings.schemaMatchMode,
+            },
+          };
+          break;
+        }
+      }
+
+      ctx.body = { data: result };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  /**
+   * GET /enforcement/schema/:uid
+   * Get local schema for a content type
+   */
+  async getLocalSchema(ctx) {
+    const { uid } = ctx.params;
+    try {
+      const schema = strapi.plugin(PLUGIN_ID).service('syncEnforcement').getLocalSchema(uid);
+      if (!schema) {
+        return ctx.throw(404, `Content type "${uid}" not found`);
+      }
+      ctx.body = { data: { uid, schema } };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  /**
+   * POST /enforcement/check
+   * Run pre-sync enforcement checks
+   */
+  async runChecks(ctx) {
+    const { contentType, remoteInfo } = ctx.request.body;
+    if (!contentType) {
+      return ctx.throw(400, 'contentType is required');
+    }
+    if (!remoteInfo) {
+      return ctx.throw(400, 'remoteInfo is required');
+    }
+    try {
+      const results = await strapi.plugin(PLUGIN_ID).service('syncEnforcement').runPreSyncChecks(contentType, remoteInfo);
+      ctx.body = { data: results };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  /**
+   * GET /enforcement/summary
+   * Get enforcement summary for UI
+   */
+  async getSummary(ctx) {
+    try {
+      const summary = await strapi.plugin(PLUGIN_ID).service('syncEnforcement').getEnforcementSummary();
+      ctx.body = { data: summary };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+});

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

@@ -0,0 +1,134 @@
+'use strict';
+
+const PLUGIN_ID = 'strapi-content-sync-pro';
+
+module.exports = ({ strapi }) => ({
+  /**
+   * GET /sync-execution/settings
+   * Get all execution settings
+   */
+  async getSettings(ctx) {
+    try {
+      const settings = await strapi.plugin(PLUGIN_ID).service('syncExecution').getExecutionSettings();
+      ctx.body = { data: settings };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  /**
+   * GET /sync-execution/settings/:profileId
+   * Get execution settings for a profile
+   */
+  async getProfileSettings(ctx) {
+    const { profileId } = ctx.params;
+    try {
+      const settings = await strapi.plugin(PLUGIN_ID).service('syncExecution').getProfileExecutionSettings(profileId);
+      ctx.body = { data: settings };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  /**
+   * PUT /sync-execution/settings/:profileId
+   * Update execution settings for a profile
+   */
+  async updateProfileSettings(ctx) {
+    const { profileId } = ctx.params;
+    const body = ctx.request.body;
+    try {
+      const settings = await strapi.plugin(PLUGIN_ID).service('syncExecution').setProfileExecutionSettings(profileId, body);
+      ctx.body = { data: settings };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  /**
+   * GET /sync-execution/global-settings
+   * Get global execution settings
+   */
+  async getGlobalSettings(ctx) {
+    try {
+      const settings = await strapi.plugin(PLUGIN_ID).service('syncExecution').getGlobalSettings();
+      ctx.body = { data: settings };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  /**
+   * PUT /sync-execution/global-settings
+   * Update global execution settings
+   */
+  async updateGlobalSettings(ctx) {
+    const body = ctx.request.body;
+    try {
+      const settings = await strapi.plugin(PLUGIN_ID).service('syncExecution').setGlobalSettings(body);
+      ctx.body = { data: settings };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  /**
+   * POST /sync-execution/execute/:profileId
+   * Execute a profile on-demand
+   */
+  async executeProfile(ctx) {
+    const { profileId } = ctx.params;
+    const options = ctx.request.body || {};
+    try {
+      const result = await strapi.plugin(PLUGIN_ID).service('syncExecution').executeProfile(profileId, options);
+      ctx.body = { data: result };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  /**
+   * POST /sync-execution/execute-batch
+   * Execute multiple profiles
+   */
+  async executeProfiles(ctx) {
+    const { profileIds, options } = ctx.request.body;
+    if (!profileIds || !Array.isArray(profileIds)) {
+      return ctx.throw(400, 'profileIds array is required');
+    }
+    try {
+      const result = await strapi.plugin(PLUGIN_ID).service('syncExecution').executeProfiles(profileIds, options || {});
+      ctx.body = { data: result };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  /**
+   * POST /sync-execution/execute-content-type/:uid
+   * Execute active profile for a content type
+   */
+  async executeContentType(ctx) {
+    const { uid } = ctx.params;
+    const options = ctx.request.body || {};
+    try {
+      const result = await strapi.plugin(PLUGIN_ID).service('syncExecution').executeContentType(uid, options);
+      ctx.body = { data: result };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  /**
+   * GET /sync-execution/status
+   * Get execution status for all profiles
+   */
+  async getStatus(ctx) {
+    try {
+      const status = await strapi.plugin(PLUGIN_ID).service('syncExecution').getExecutionStatus();
+      ctx.body = { data: status };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+});

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

@@ -0,0 +1,18 @@
+'use strict';
+
+module.exports = {
+  async find(ctx) {
+    const { page, pageSize, status, contentType, action } = ctx.query;
+
+    const service = strapi.plugin('strapi-content-sync-pro').service('syncLog');
+    const result = await service.getLogs({
+      page: page ? parseInt(page, 10) : 1,
+      pageSize: pageSize ? parseInt(pageSize, 10) : 25,
+      status,
+      contentType,
+      action,
+    });
+
+    ctx.body = result;
+  },
+};

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

@@ -0,0 +1,158 @@
+'use strict';
+
+const PLUGIN_ID = 'strapi-content-sync-pro';
+
+function service(strapi) {
+  return strapi.plugin(PLUGIN_ID).service('syncMedia');
+}
+
+module.exports = ({ strapi }) => ({
+  // ── Profile CRUD ──────────────────────────────────────────────────────────
+
+  async getProfiles(ctx) {
+    try {
+      ctx.body = { data: await service(strapi).getProfiles() };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  async getProfile(ctx) {
+    try {
+      const profile = await service(strapi).getProfile(ctx.params.id);
+      if (!profile) return ctx.throw(404, 'Media profile not found');
+      ctx.body = { data: profile };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  async createProfile(ctx) {
+    try {
+      const body = ctx.request.body || {};
+      ctx.body = { data: await service(strapi).createProfile(body) };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  async updateProfile(ctx) {
+    try {
+      const body = ctx.request.body || {};
+      ctx.body = { data: await service(strapi).updateProfile(ctx.params.id, body) };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  async deleteProfile(ctx) {
+    try {
+      ctx.body = { data: await service(strapi).deleteProfile(ctx.params.id) };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  async activateProfile(ctx) {
+    try {
+      ctx.body = { data: await service(strapi).activateProfile(ctx.params.id) };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  // ── Global settings ───────────────────────────────────────────────────────
+
+  async getGlobalSettings(ctx) {
+    try {
+      ctx.body = { data: await service(strapi).getGlobalSettings() };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  async updateGlobalSettings(ctx) {
+    try {
+      const body = ctx.request.body || {};
+      ctx.body = { data: await service(strapi).setGlobalSettings(body) };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  // ── Defaults / constants ──────────────────────────────────────────────────
+
+  async getDefaults(ctx) {
+    try {
+      ctx.body = { data: service(strapi).getDefaults() };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  // ── Execution ─────────────────────────────────────────────────────────────
+
+  async runProfile(ctx) {
+    try {
+      const options = ctx.request.body || {};
+      const result = await service(strapi).runProfile(ctx.params.id, options);
+      ctx.body = { data: result };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  async runActiveProfiles(ctx) {
+    try {
+      const results = await service(strapi).runActiveProfiles();
+      ctx.body = { data: results };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  // ── Back-compat (old flat endpoints) ──────────────────────────────────────
+
+  async getSettings(ctx) {
+    try {
+      ctx.body = { data: await service(strapi).getSettings() };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  async updateSettings(ctx) {
+    try {
+      const body = ctx.request.body || {};
+      ctx.body = { data: await service(strapi).setSettings(body) };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  async getStatus(ctx) {
+    try {
+      ctx.body = { data: await service(strapi).getStatus() };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  async test(ctx) {
+    try {
+      ctx.body = { data: await service(strapi).testConnection() };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  async run(ctx) {
+    try {
+      const options = ctx.request.body || {};
+      const result = await service(strapi).run(options);
+      ctx.body = { data: result };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+});