strapi-content-sync-pro 1.0.0

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

@@ -0,0 +1,182 @@
+'use strict';
+
+const PLUGIN_ID = 'strapi-content-sync-pro';
+
+module.exports = ({ strapi }) => ({
+  /**
+   * GET /sync-profiles
+   * List all sync profiles
+   */
+  async find(ctx) {
+    try {
+      const profiles = await strapi.plugin(PLUGIN_ID).service('syncProfiles').getProfiles();
+      ctx.body = { data: profiles };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  /**
+   * GET /sync-profiles/:id
+   * Get a single sync profile
+   */
+  async findOne(ctx) {
+    const { id } = ctx.params;
+    try {
+      const profile = await strapi.plugin(PLUGIN_ID).service('syncProfiles').getProfile(id);
+      if (!profile) {
+        return ctx.throw(404, `Profile with id "${id}" not found`);
+      }
+      ctx.body = { data: profile };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  /**
+   * GET /sync-profiles/content-type/:uid
+   * Get all profiles for a content type
+   */
+  async findByContentType(ctx) {
+    const { uid } = ctx.params;
+    try {
+      const profiles = await strapi.plugin(PLUGIN_ID).service('syncProfiles').getProfilesForContentType(uid);
+      ctx.body = { data: profiles };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  /**
+   * GET /sync-profiles/content-type/:uid/active
+   * Get active profile for a content type
+   */
+  async findActiveByContentType(ctx) {
+    const { uid } = ctx.params;
+    try {
+      const profile = await strapi.plugin(PLUGIN_ID).service('syncProfiles').getActiveProfileForContentType(uid);
+      ctx.body = { data: profile };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  /**
+   * POST /sync-profiles
+   * Create a new sync profile
+   */
+  async create(ctx) {
+    const body = ctx.request.body;
+    try {
+      const profile = await strapi.plugin(PLUGIN_ID).service('syncProfiles').createProfile(body);
+      ctx.body = { data: profile };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  /**
+   * POST /sync-profiles/auto-generate
+   * Auto-generate default profiles for a content type
+   */
+  async autoGenerate(ctx) {
+    const { contentType } = ctx.request.body;
+    if (!contentType) {
+      return ctx.throw(400, 'contentType is required');
+    }
+    try {
+      const profiles = await strapi.plugin(PLUGIN_ID).service('syncProfiles').autoGenerateProfiles(contentType);
+      ctx.body = { data: profiles };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  /**
+   * POST /sync-profiles/simple
+   * Create a simple preset profile
+   */
+  async createSimple(ctx) {
+    const { contentType, preset } = ctx.request.body;
+    if (!contentType) {
+      return ctx.throw(400, 'contentType is required');
+    }
+    if (!preset) {
+      return ctx.throw(400, 'preset is required');
+    }
+    try {
+      const profile = await strapi.plugin(PLUGIN_ID).service('syncProfiles').createSimpleProfile(contentType, preset);
+      ctx.body = { data: profile };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  /**
+   * PUT /sync-profiles/:id
+   * Update an existing sync profile
+   */
+  async update(ctx) {
+    const { id } = ctx.params;
+    const body = ctx.request.body;
+    try {
+      const profile = await strapi.plugin(PLUGIN_ID).service('syncProfiles').updateProfile(id, body);
+      ctx.body = { data: profile };
+    } catch (err) {
+      if (err.message.includes('not found')) {
+        return ctx.throw(404, err.message);
+      }
+      ctx.throw(400, err.message);
+    }
+  },
+
+  /**
+   * DELETE /sync-profiles/:id
+   * Delete a sync profile
+   */
+  async delete(ctx) {
+    const { id } = ctx.params;
+    try {
+      const result = await strapi.plugin(PLUGIN_ID).service('syncProfiles').deleteProfile(id);
+      ctx.body = { data: result };
+    } catch (err) {
+      if (err.message.includes('not found')) {
+        return ctx.throw(404, err.message);
+      }
+      ctx.throw(500, err.message);
+    }
+  },
+
+  /**
+   * GET /content-type-schema/:uid
+   * Get schema/fields for a content type (for UI to display available fields)
+   */
+  async getContentTypeSchema(ctx) {
+    const { uid } = ctx.params;
+    try {
+      const contentType = strapi.contentTypes[uid];
+      if (!contentType) {
+        return ctx.throw(404, `Content type "${uid}" not found`);
+      }
+
+      const attributes = contentType.attributes || {};
+      const fields = Object.entries(attributes).map(([name, attr]) => ({
+        name,
+        type: attr.type,
+        required: attr.required || false,
+        relation: attr.type === 'relation' ? attr.relation : null,
+        target: attr.target || null,
+      }));
+
+      ctx.body = {
+        data: {
+          uid,
+          displayName: contentType.info?.displayName || uid,
+          fields,
+        },
+      };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+});

package/server/src/controllers/sync.js

@@ -0,0 +1,31 @@
+'use strict';
+
+module.exports = {
+  async syncNow(ctx) {
+    const syncService = strapi.plugin('strapi-content-sync-pro').service('sync');
+
+    try {
+      const result = await syncService.syncNow();
+      ctx.body = { data: result };
+    } catch (err) {
+      return ctx.badRequest(err.message);
+    }
+  },
+
+  async receive(ctx) {
+    const { body } = ctx.request;
+
+    if (!body || !body.uid || !body.syncId) {
+      return ctx.badRequest('Missing uid, data, or syncId');
+    }
+
+    const syncService = strapi.plugin('strapi-content-sync-pro').service('sync');
+
+    try {
+      const result = await syncService.receiveRecord(body.uid, body.data || {}, body.syncId);
+      ctx.body = { data: result };
+    } catch (err) {
+      return ctx.badRequest(err.message);
+    }
+  },
+};

package/server/src/destroy.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const destroy = ({ strapi }) => {
+  // destroy phase
+};
+
+module.exports = destroy;

package/server/src/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const register = require('./register');
+const bootstrap = require('./bootstrap');
+const destroy = require('./destroy');
+const config = require('./config');
+const contentTypes = require('./content-types');
+const controllers = require('./controllers');
+const routes = require('./routes');
+const services = require('./services');
+
+module.exports = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  routes,
+  controllers,
+  services,
+  contentTypes,
+};

package/server/src/middlewares/verify-signature.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const { verifySignature } = require('../utils/hmac');
+
+/**
+ * Koa middleware that validates the HMAC signature sent by a remote
+ * Strapi instance.  Used on the /receive endpoint.
+ */
+module.exports = async (ctx, next) => {
+  const signature = ctx.request.headers['x-sync-signature'];
+  const timestamp = ctx.request.headers['x-sync-timestamp'];
+
+  if (!signature || !timestamp) {
+    return ctx.unauthorized('Missing x-sync-signature or x-sync-timestamp header');
+  }
+
+  const configService = strapi.plugin('strapi-content-sync-pro').service('config');
+  const serverConfig = await configService.getConfig({ safe: false });
+
+  if (!serverConfig || !serverConfig.sharedSecret) {
+    return ctx.unauthorized('Server not configured for sync');
+  }
+
+  const body = ctx.request.body || {};
+  const isValid = verifySignature(body, serverConfig.sharedSecret, signature, timestamp);
+
+  if (!isValid) {
+    return ctx.unauthorized('Invalid sync signature');
+  }
+
+  await next();
+};

package/server/src/register.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const register = ({ strapi }) => {
+  // register phase
+};
+
+module.exports = register;

package/server/src/routes/index.js

@@ -0,0 +1,111 @@
+'use strict';
+
+const verifySignature = require('../middlewares/verify-signature');
+
+/**
+ * Strapi v5 plugin routes MUST be split between:
+ *   - content-api: exposed under /api/<plugin>/...  (remote server calls)
+ *   - admin:       exposed under /<plugin>/...      (local admin UI calls)
+ */
+
+const contentApiRoutes = [
+  { method: 'GET',  path: '/ping',                    handler: 'ping.index',                     config: { policies: [], auth: false } },
+  { 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] } },
+];
+
+const adminRoutes = [
+  // Config
+  { method: 'GET',  path: '/config',              handler: 'config.get',         config: { policies: [] } },
+  { method: 'POST', path: '/config',              handler: 'config.set',         config: { policies: [] } },
+  { method: 'POST', path: '/config/remote-login', handler: 'config.remoteLogin', config: { policies: [] } },
+  { method: 'GET',  path: '/config/test',         handler: 'config.test',        config: { policies: [] } },
+
+  // Content-type discovery
+  { method: 'GET', path: '/content-types', handler: 'contentTypeDiscovery.find', config: { policies: [] } },
+
+  // Sync configuration
+  { method: 'GET',  path: '/sync-config', handler: 'syncConfig.get', config: { policies: [] } },
+  { method: 'POST', path: '/sync-config', handler: 'syncConfig.set', config: { policies: [] } },
+
+  // Manual sync trigger
+  { method: 'POST', path: '/sync-now', handler: 'sync.syncNow', config: { policies: [] } },
+
+  // Logs
+  { method: 'GET', path: '/logs', handler: 'syncLog.find', 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: [] } },
+  { method: 'GET',    path: '/sync-profiles/content-type/:uid',        handler: 'syncProfiles.findByContentType',       config: { policies: [] } },
+  { method: 'GET',    path: '/sync-profiles/content-type/:uid/active', handler: 'syncProfiles.findActiveByContentType', config: { policies: [] } },
+  { method: 'POST',   path: '/sync-profiles',                          handler: 'syncProfiles.create',                  config: { policies: [] } },
+  { method: 'POST',   path: '/sync-profiles/auto-generate',            handler: 'syncProfiles.autoGenerate',            config: { policies: [] } },
+  { method: 'POST',   path: '/sync-profiles/simple',                   handler: 'syncProfiles.createSimple',            config: { policies: [] } },
+  { method: 'PUT',    path: '/sync-profiles/:id',                      handler: 'syncProfiles.update',                  config: { policies: [] } },
+  { method: 'DELETE', path: '/sync-profiles/:id',                      handler: 'syncProfiles.delete',                  config: { policies: [] } },
+  { method: 'GET',    path: '/content-type-schema/:uid',               handler: 'syncProfiles.getContentTypeSchema',    config: { policies: [] } },
+
+  // Sync Execution
+  { method: 'GET',  path: '/sync-execution/settings',                  handler: 'syncExecution.getSettings',           config: { policies: [] } },
+  { method: 'GET',  path: '/sync-execution/settings/:profileId',       handler: 'syncExecution.getProfileSettings',    config: { policies: [] } },
+  { method: 'PUT',  path: '/sync-execution/settings/:profileId',       handler: 'syncExecution.updateProfileSettings', config: { policies: [] } },
+  { method: 'GET',  path: '/sync-execution/global-settings',           handler: 'syncExecution.getGlobalSettings',     config: { policies: [] } },
+  { method: 'PUT',  path: '/sync-execution/global-settings',           handler: 'syncExecution.updateGlobalSettings',  config: { policies: [] } },
+  { method: 'POST', path: '/sync-execution/execute/:profileId',        handler: 'syncExecution.executeProfile',        config: { policies: [] } },
+  { method: 'POST', path: '/sync-execution/execute-batch',             handler: 'syncExecution.executeProfiles',       config: { policies: [] } },
+  { method: 'POST', path: '/sync-execution/execute-content-type/:uid', handler: 'syncExecution.executeContentType',    config: { policies: [] } },
+  { method: 'GET',  path: '/sync-execution/status',                    handler: 'syncExecution.getStatus',             config: { policies: [] } },
+
+  // Enforcement (admin-side)
+  { method: 'GET',  path: '/enforcement/settings',    handler: 'syncEnforcement.getSettings',        config: { policies: [] } },
+  { method: 'PUT',  path: '/enforcement/settings',    handler: 'syncEnforcement.updateSettings',     config: { policies: [] } },
+  { method: 'GET',  path: '/enforcement/remote-info', handler: 'syncEnforcement.getRemoteInfo',      config: { policies: [] } },
+  { method: 'GET',  path: '/enforcement/check/:type', handler: 'syncEnforcement.runDiagnosticCheck', config: { policies: [] } },
+  { method: 'POST', path: '/enforcement/check',       handler: 'syncEnforcement.runChecks',          config: { policies: [] } },
+  { method: 'GET',  path: '/enforcement/summary',     handler: 'syncEnforcement.getSummary',         config: { policies: [] } },
+
+  // Alerts
+  { method: 'GET',  path: '/alerts/settings',      handler: 'alerts.getSettings',    config: { policies: [] } },
+  { method: 'PUT',  path: '/alerts/settings',      handler: 'alerts.updateSettings', config: { policies: [] } },
+  { method: 'POST', path: '/alerts/test/:channel', handler: 'alerts.testChannel',    config: { policies: [] } },
+  { method: 'GET',  path: '/alerts/stats',         handler: 'alerts.getStats',       config: { policies: [] } },
+
+  // Media sync
+  { method: 'GET',    path: '/media-sync/profiles',              handler: 'syncMedia.getProfiles',         config: { policies: [] } },
+  { method: 'GET',    path: '/media-sync/profiles/:id',          handler: 'syncMedia.getProfile',          config: { policies: [] } },
+  { method: 'POST',   path: '/media-sync/profiles',              handler: 'syncMedia.createProfile',       config: { policies: [] } },
+  { method: 'PUT',    path: '/media-sync/profiles/:id',          handler: 'syncMedia.updateProfile',       config: { policies: [] } },
+  { method: 'DELETE', path: '/media-sync/profiles/:id',          handler: 'syncMedia.deleteProfile',       config: { policies: [] } },
+  { 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/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: [] } },
+  { method: 'GET',    path: '/media-sync/settings',              handler: 'syncMedia.getSettings',         config: { policies: [] } },
+  { method: 'PUT',    path: '/media-sync/settings',              handler: 'syncMedia.updateSettings',      config: { policies: [] } },
+  { method: 'GET',    path: '/media-sync/status',                handler: 'syncMedia.getStatus',           config: { policies: [] } },
+  { method: 'POST',   path: '/media-sync/test',                  handler: 'syncMedia.test',                config: { policies: [] } },
+  { method: 'POST',   path: '/media-sync/run',                   handler: 'syncMedia.run',                 config: { policies: [] } },
+
+  // Dependencies
+  { method: 'GET',  path: '/dependencies/all',             handler: 'dependencies.analyzeAll',   config: { policies: [] } },
+  { method: 'GET',  path: '/dependencies/:uid',            handler: 'dependencies.analyze',      config: { policies: [] } },
+  { method: 'GET',  path: '/dependencies/:uid/graph',      handler: 'dependencies.getGraph',     config: { policies: [] } },
+  { method: 'GET',  path: '/dependencies/:uid/sync-order', handler: 'dependencies.getSyncOrder', config: { policies: [] } },
+  { method: 'GET',  path: '/dependencies/:uid/summary',    handler: 'dependencies.getSummary',   config: { policies: [] } },
+  { method: 'POST', path: '/dependencies/clear-cache',     handler: 'dependencies.clearCache',   config: { policies: [] } },
+];
+
+module.exports = {
+  'content-api': {
+    type: 'content-api',
+    routes: contentApiRoutes,
+  },
+  admin: {
+    type: 'admin',
+    routes: adminRoutes,
+  },
+};