strapi-content-sync-pro 1.0.6 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strapi-content-sync-pro",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Strapi v5 plugin to copy, migrate, and live-sync content, media, and data between multiple Strapi environments with bi-directional sync, field-level policies, scheduling, and alerts.",
   "license": "MIT",
   "author": {

package/server/src/bootstrap.js

@@ -139,6 +139,12 @@ const bootstrap = ({ strapi }) => {
   // Defer scheduler initialization
   setImmediate(async () => {
     try {
+      const workflowNotificationsService = strapi.plugin('strapi-content-sync-pro').service('workflowNotifications');
+      const seedResult = await workflowNotificationsService.seedTemplates();
+      if (seedResult.seeded) {
+        strapi.log.info(`[data-sync] Seeded ${seedResult.total} workflow notification templates`);
+      }
+
       const executionService = strapi.plugin('strapi-content-sync-pro').service('syncExecution');
       await executionService.initializeSchedulers();
       strapi.log.info('[data-sync] Scheduled sync jobs initialized');

package/server/src/content-types/index.js

@@ -2,8 +2,10 @@
 
 const syncLogSchema = require('./sync-log/schema.json');
 const syncRunReportSchema = require('./sync-run-report/schema.json');
+const workflowNotificationSchema = require('./workflow-notification/schema.json');
 
 module.exports = {
   'sync-log': { schema: syncLogSchema },
   'sync-run-report': { schema: syncRunReportSchema },
+  'workflow-notification': { schema: workflowNotificationSchema },
 };

package/server/src/content-types/workflow-notification/schema.json

@@ -0,0 +1,26 @@
+{
+  "kind": "collectionType",
+  "collectionName": "workflow_notifications",
+  "info": {
+    "singularName": "workflow-notification",
+    "pluralName": "workflow-notifications",
+    "displayName": "Workflow Notification"
+  },
+  "options": {},
+  "pluginOptions": {
+    "content-manager": { "visible": false },
+    "content-type-builder": { "visible": false }
+  },
+  "attributes": {
+    "sourceApp": { "type": "enumeration", "enum": ["web", "web-user-app"] },
+    "workflow": { "type": "enumeration", "enum": ["order", "purchase"] },
+    "event": { "type": "string" },
+    "title": { "type": "string", "required": true },
+    "message": { "type": "text", "required": true },
+    "status": { "type": "enumeration", "enum": ["pending", "sent", "failed"], "default": "pending" },
+    "recipient": { "type": "string" },
+    "orderId": { "type": "string" },
+    "purchaseId": { "type": "string" },
+    "metadata": { "type": "json" }
+  }
+}

package/server/src/controllers/index.js

@@ -11,6 +11,7 @@ const syncExecution = require('./sync-execution');
 const syncEnforcement = require('./sync-enforcement');
 const syncMedia = require('./sync-media');
 const alerts = require('./alerts');
+const workflowNotifications = require('./workflow-notifications');
 const dependencies = require('./dependencies');
 const syncStats = require('./sync-stats');
 const bulkTransfer = require('./bulk-transfer');
@@ -27,6 +28,7 @@ module.exports = {
   syncEnforcement,
   syncMedia,
   alerts,
+  workflowNotifications,
   dependencies,
   syncStats,
   bulkTransfer,

package/server/src/controllers/workflow-notifications.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const PLUGIN_ID = 'strapi-content-sync-pro';
+
+module.exports = ({ strapi }) => ({
+  async emit(ctx) {
+    try {
+      const payload = ctx.request.body || {};
+      const data = await strapi.plugin(PLUGIN_ID).service('workflowNotifications').emit(payload);
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  async find(ctx) {
+    try {
+      const { page, pageSize, sourceApp, workflow, event, status } = ctx.query;
+      const result = await strapi.plugin(PLUGIN_ID).service('workflowNotifications').list({
+        page: page ? parseInt(page, 10) : 1,
+        pageSize: pageSize ? parseInt(pageSize, 10) : 25,
+        sourceApp,
+        workflow,
+        event,
+        status,
+      });
+
+      ctx.body = result;
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  async getTemplates(ctx) {
+    try {
+      const templates = await strapi.plugin(PLUGIN_ID).service('workflowNotifications').getTemplates();
+      ctx.body = { data: templates };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  async seedTemplates(ctx) {
+    try {
+      const result = await strapi.plugin(PLUGIN_ID).service('workflowNotifications').seedTemplates();
+      ctx.body = { data: result };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+});

package/server/src/index.js

@@ -8,6 +8,7 @@ const contentTypes = require('./content-types');
 const controllers = require('./controllers');
 const routes = require('./routes');
 const services = require('./services');
+const middlewares = require('./middlewares');
 
 module.exports = {
   register,
@@ -18,4 +19,5 @@ module.exports = {
   controllers,
   services,
   contentTypes,
+  middlewares,
 };

package/server/src/middlewares/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const verifySignature = require('./verify-signature');
+
+/**
+ * Strapi v5 plugin middleware registry.
+ * Each entry must be a middleware factory: (config, { strapi }) => (ctx, next) => {...}.
+ * Middlewares are referenced by name string in route configs:
+ *   middlewares: ['plugin::strapi-content-sync-pro.verifySignature']
+ */
+module.exports = {
+  verifySignature,
+};

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

@@ -1,32 +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();
-};
+'use strict';
+
+const { verifySignature } = require('../utils/hmac');
+
+/**
+ * Strapi v5 middleware factory. Validates the HMAC signature sent by a
+ * remote Strapi instance. Used on the /receive endpoint.
+ */
+module.exports = (config, { strapi }) => 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/routes/index.js

@@ -1,7 +1,5 @@
 '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)
@@ -12,7 +10,11 @@ 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] } },
+  { method: 'POST', path: '/receive',                 handler: 'sync.receive',                   config: { policies: [], auth: false, middlewares: ['plugin::strapi-content-sync-pro.verifySignature'] } },
+  { method: 'POST', path: '/workflow-notifications/emit',      handler: 'workflowNotifications.emit',         config: { policies: [], auth: false } },
+  { method: 'GET',  path: '/workflow-notifications',           handler: 'workflowNotifications.find',         config: { policies: [] } },
+  { method: 'GET',  path: '/workflow-notifications/templates', handler: 'workflowNotifications.getTemplates', config: { policies: [] } },
+  { method: 'POST', path: '/workflow-notifications/seed',      handler: 'workflowNotifications.seedTemplates', config: { policies: [] } },
 
   // Media morph-link sync (called by the peer instance during runProfile)
   { method: 'GET',  path: '/media-sync/morph-links',       handler: 'syncMedia.getMorphLinks',   config: { policies: [] } },
@@ -83,6 +85,11 @@ const adminRoutes = [
   { method: 'POST', path: '/alerts/test/:channel', handler: 'alerts.testChannel',    config: { policies: [] } },
   { method: 'GET',  path: '/alerts/stats',         handler: 'alerts.getStats',       config: { policies: [] } },
 
+  // Workflow notifications
+  { method: 'GET',  path: '/workflow-notifications',           handler: 'workflowNotifications.find',         config: { policies: [] } },
+  { method: 'GET',  path: '/workflow-notifications/templates', handler: 'workflowNotifications.getTemplates', config: { policies: [] } },
+  { method: 'POST', path: '/workflow-notifications/seed',      handler: 'workflowNotifications.seedTemplates', 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: [] } },

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 workflowNotifications = require('./workflow-notifications');
 const syncStats = require('./sync-stats');
 const bulkTransfer = require('./bulk-transfer');
 
@@ -28,6 +29,7 @@ module.exports = {
   syncEnforcement,
   syncMedia,
   alerts,
+  workflowNotifications,
   syncStats,
   bulkTransfer,
 };

package/server/src/services/workflow-notifications.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const CONTENT_TYPE_UID = 'plugin::strapi-content-sync-pro.workflow-notification';
+const STORE_KEY = 'workflow-notification-templates';
+
+const DEFAULT_TEMPLATES = [
+  {
+    sourceApp: 'web',
+    workflow: 'order',
+    event: 'order_created',
+    title: 'New order placed',
+    message: 'Order {{orderId}} placed by {{customerName}} for {{amount}}.',
+  },
+  {
+    sourceApp: 'web',
+    workflow: 'order',
+    event: 'order_paid',
+    title: 'Order payment received',
+    message: 'Payment received for order {{orderId}}.',
+  },
+  {
+    sourceApp: 'web-user-app',
+    workflow: 'purchase',
+    event: 'purchase_initiated',
+    title: 'Purchase initiated',
+    message: 'User {{userId}} initiated purchase {{purchaseId}}.',
+  },
+  {
+    sourceApp: 'web-user-app',
+    workflow: 'purchase',
+    event: 'purchase_completed',
+    title: 'Purchase completed',
+    message: 'Purchase {{purchaseId}} completed successfully for {{userId}}.',
+  },
+];
+
+module.exports = ({ strapi }) => ({
+  getStore() {
+    return strapi.store({ type: 'plugin', name: 'strapi-content-sync-pro' });
+  },
+
+  interpolate(template, payload = {}) {
+    return template.replace(/\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g, (_, key) => {
+      const value = payload[key];
+      return value === undefined || value === null ? '' : String(value);
+    });
+  },
+
+  async seedTemplates() {
+    const store = this.getStore();
+    const existing = await store.get({ key: STORE_KEY });
+
+    if (Array.isArray(existing) && existing.length > 0) {
+      return { seeded: false, total: existing.length };
+    }
+
+    await store.set({ key: STORE_KEY, value: DEFAULT_TEMPLATES });
+    return { seeded: true, total: DEFAULT_TEMPLATES.length };
+  },
+
+  async getTemplates() {
+    const store = this.getStore();
+    const templates = await store.get({ key: STORE_KEY });
+    if (Array.isArray(templates) && templates.length > 0) {
+      return templates;
+    }
+
+    await this.seedTemplates();
+    return DEFAULT_TEMPLATES;
+  },
+
+  async findTemplate({ sourceApp, workflow, event }) {
+    const templates = await this.getTemplates();
+    return templates.find((template) => (
+      template.sourceApp === sourceApp
+      && template.workflow === workflow
+      && template.event === event
+    ));
+  },
+
+  async emit(payload = {}) {
+    const { sourceApp, workflow, event, recipient, metadata } = payload;
+
+    if (!sourceApp || !workflow || !event) {
+      throw new Error('sourceApp, workflow, and event are required');
+    }
+
+    const template = await this.findTemplate({ sourceApp, workflow, event });
+    if (!template) {
+      throw new Error(`No notification template found for ${sourceApp}/${workflow}/${event}`);
+    }
+
+    const title = this.interpolate(template.title, payload);
+    const message = this.interpolate(template.message, payload);
+
+    const entry = await strapi.documents(CONTENT_TYPE_UID).create({
+      data: {
+        sourceApp,
+        workflow,
+        event,
+        title,
+        message,
+        recipient: recipient || '',
+        orderId: payload.orderId || '',
+        purchaseId: payload.purchaseId || '',
+        status: 'pending',
+        metadata: metadata || payload,
+      },
+    });
+
+    return entry;
+  },
+
+  async list({ page = 1, pageSize = 25, sourceApp, workflow, event, status } = {}) {
+    const filters = {};
+    if (sourceApp) filters.sourceApp = sourceApp;
+    if (workflow) filters.workflow = workflow;
+    if (event) filters.event = event;
+    if (status) filters.status = status;
+
+    const start = (page - 1) * pageSize;
+
+    const [entries, total] = await Promise.all([
+      strapi.documents(CONTENT_TYPE_UID).findMany({
+        filters,
+        sort: { createdAt: 'desc' },
+        limit: pageSize,
+        start,
+      }),
+      strapi.documents(CONTENT_TYPE_UID).count({ filters }),
+    ]);
+
+    return {
+      data: entries,
+      meta: {
+        pagination: {
+          page,
+          pageSize,
+          pageCount: Math.ceil(total / pageSize),
+          total,
+        },
+      },
+    };
+  },
+});