strapi-content-sync-pro 1.0.3 → 1.0.5

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "strapi-content-sync-pro",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "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": {
-    "name": "Ejaz Husain Arain",
+    "name": "Ejaz Hussain Arain",
     "email": "eharain@yahoo.com",
-    "url": "https://github.com/eharain"
+    "url": "https://www.linkedin.com/in/ejazarain"
   },
   "repository": {
     "type": "git",
@@ -24,7 +24,10 @@
     "strapi",
     "strapi-plugin",
     "strapi-v5",
+    "strapi pulgin to transfer content",
     "sync",
+    "hot sync",
+    "real-time sync",
     "live-sync",
     "data-sync",
     "content-sync",
@@ -39,7 +42,13 @@
     "cross-environment",
     "data-transfer",
     "headless-cms",
-    "content-management"
+    "content-management",
+    "data transfer",
+    "bulk transfer",
+    "field-level policies",
+    "scheduling",
+    "alerts",
+    "bi-directional sync"
   ],
   "exports": {
     "./strapi-admin": {

package/server/src/controllers/bulk-transfer.js

@@ -0,0 +1,141 @@
+'use strict';
+
+const PLUGIN_ID = 'strapi-content-sync-pro';
+
+function svc(strapi) {
+  return strapi.plugin(PLUGIN_ID).service('bulkTransfer');
+}
+
+module.exports = ({ strapi }) => ({
+  async preview(ctx) {
+    try {
+      const body = ctx.request.body || {};
+      const data = await svc(strapi).preview({
+        direction: body.direction,
+        scopes: body.scopes,
+      });
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  async start(ctx) {
+    try {
+      const body = ctx.request.body || {};
+      const data = await svc(strapi).start(body);
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  async next(ctx) {
+    try {
+      const { jobId } = ctx.params;
+      const data = await svc(strapi).next(jobId);
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  async runAll(ctx) {
+    try {
+      const { jobId } = ctx.params;
+      const data = await svc(strapi).runToCompletion(jobId);
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  async status(ctx) {
+    try {
+      const { jobId } = ctx.params;
+      const data = svc(strapi).getStatus(jobId);
+      if (!data) return ctx.notFound('Job not found');
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  async cancel(ctx) {
+    try {
+      const { jobId } = ctx.params;
+      const data = await svc(strapi).cancel(jobId);
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  async pause(ctx) {
+    try {
+      const { jobId } = ctx.params;
+      const data = await svc(strapi).pause(jobId);
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  async resume(ctx) {
+    try {
+      const { jobId } = ctx.params;
+      const data = await svc(strapi).resume(jobId);
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  async list(ctx) {
+    try {
+      ctx.body = { data: svc(strapi).listJobs() };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  async history(ctx) {
+    try {
+      const data = await svc(strapi).getHistory();
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  async clearHistory(ctx) {
+    try {
+      const data = await svc(strapi).clearHistory();
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(500, err.message);
+    }
+  },
+
+  async restart(ctx) {
+    try {
+      const { historyId } = ctx.params;
+      const body = ctx.request.body || {};
+      const data = await svc(strapi).restart(historyId, body);
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  async resumeFromHistory(ctx) {
+    try {
+      const { historyId } = ctx.params;
+      const body = ctx.request.body || {};
+      const data = await svc(strapi).resumeFromHistory(historyId, body);
+      ctx.body = { data };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+});

package/server/src/controllers/config.js

@@ -198,12 +198,69 @@ module.exports = {
    * Proxy login to remote Strapi and retrieve/create API token
    */
   async remoteLogin(ctx) {
-    const { baseUrl, email, password } = ctx.request.body;
+    const { baseUrl: rawBaseUrl, email, password } = ctx.request.body;
 
-    if (!baseUrl || !email || !password) {
+    if (!rawBaseUrl || !email || !password) {
       return ctx.badRequest('baseUrl, email, and password are required');
     }
 
+    // --- Normalize and validate the base URL so URL mistakes produce a clear message ---
+    let baseUrl = String(rawBaseUrl).trim();
+    if (!/^https?:\/\//i.test(baseUrl)) {
+      return ctx.badRequest(
+        `Invalid Server URL "${rawBaseUrl}": must start with http:// or https:// (e.g. http://localhost:4010)`
+      );
+    }
+    // Strip trailing slashes and accidental /admin suffix
+    baseUrl = baseUrl.replace(/\/+$/, '').replace(/\/admin$/i, '');
+    let parsedUrl;
+    try {
+      parsedUrl = new URL(baseUrl);
+    } catch {
+      return ctx.badRequest(
+        `Invalid Server URL "${rawBaseUrl}": not a valid URL. Expected format: http(s)://host[:port]`
+      );
+    }
+    if (!parsedUrl.hostname) {
+      return ctx.badRequest(`Invalid Server URL "${rawBaseUrl}": missing hostname`);
+    }
+
+    // --- Pre-flight reachability check against /admin/init so wrong URL != "invalid credentials" ---
+    try {
+      const initResp = await fetch(`${baseUrl}/admin/init`, { method: 'GET' });
+      if (!initResp.ok) {
+        return ctx.throw(
+          502,
+          `Server URL "${baseUrl}" is reachable but did not respond as a Strapi admin (HTTP ${initResp.status} on /admin/init). Check that the URL points to the root of a Strapi v5 server (no /admin suffix) and that the admin panel is enabled.`
+        );
+      }
+      const initData = await initResp.json().catch(() => null);
+      if (!initData || typeof initData !== 'object' || !('data' in initData)) {
+        return ctx.throw(
+          502,
+          `Server URL "${baseUrl}" did not return a valid Strapi /admin/init response. Please verify the URL points to a Strapi v5 instance.`
+        );
+      }
+      if (initData.data && initData.data.hasAdmin === false) {
+        return ctx.throw(
+          400,
+          `Remote Strapi at "${baseUrl}" has no admin user yet. Create the first admin in the remote Strapi panel before generating a token.`
+        );
+      }
+    } catch (err) {
+      if (err && err.status) throw err;
+      const code = err && (err.cause?.code || err.code);
+      const hint =
+        code === 'ECONNREFUSED'
+          ? 'Connection refused — the server is not running or not listening on that port.'
+          : code === 'ENOTFOUND'
+            ? 'Host not found — check the hostname/IP spelling and that it resolves from this machine.'
+            : code === 'ETIMEDOUT'
+              ? 'Request timed out — check firewall, network, and that the port is reachable.'
+              : 'Network error while contacting the remote server.';
+      return ctx.throw(502, `Cannot reach "${baseUrl}": ${hint}${code ? ` (${code})` : ''}`);
+    }
+
     try {
       // Step 1: Login to remote Strapi admin
       const loginResponse = await fetch(`${baseUrl}/admin/login`, {
@@ -219,7 +276,23 @@ module.exports = {
 
       if (!loginResponse.ok) {
         const errorBody = await loginResponse.json().catch(() => ({}));
-        const errorMessage = errorBody?.error?.message || `Login failed with status ${loginResponse.status}`;
+        const remoteMsg = errorBody?.error?.message;
+        // Distinguish URL-vs-credential failures so users aren't misled
+        if (loginResponse.status === 404) {
+          return ctx.throw(
+            404,
+            `"${baseUrl}/admin/login" not found (HTTP 404). The Server URL likely points to the wrong path — use the Strapi root URL (e.g. http://localhost:4010), not an admin or API sub-path.`
+          );
+        }
+        if (loginResponse.status === 405) {
+          return ctx.throw(
+            405,
+            `"${baseUrl}/admin/login" rejected the request method. The Server URL may be pointing to a proxy or non-Strapi endpoint.`
+          );
+        }
+        const errorMessage = remoteMsg
+          ? `Remote login failed: ${remoteMsg}. If you believe the credentials are correct, double-check the Server URL "${baseUrl}" is the right Strapi instance.`
+          : `Login failed with status ${loginResponse.status} at ${baseUrl}/admin/login`;
         return ctx.throw(loginResponse.status, errorMessage);
       }
 

package/server/src/controllers/index.js

@@ -13,6 +13,7 @@ const syncMedia = require('./sync-media');
 const alerts = require('./alerts');
 const dependencies = require('./dependencies');
 const syncStats = require('./sync-stats');
+const bulkTransfer = require('./bulk-transfer');
 
 module.exports = {
   ping,
@@ -28,4 +29,5 @@ module.exports = {
   alerts,
   dependencies,
   syncStats,
+  bulkTransfer,
 };

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

@@ -111,6 +111,30 @@ module.exports = ({ strapi }) => ({
     }
   },
 
+  async pauseProfile(ctx) {
+    try {
+      ctx.body = { data: await service(strapi).pauseProfile(ctx.params.id) };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  async resumeProfile(ctx) {
+    try {
+      ctx.body = { data: await service(strapi).resumeProfile(ctx.params.id) };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
+  async cancelProfile(ctx) {
+    try {
+      ctx.body = { data: await service(strapi).cancelProfile(ctx.params.id) };
+    } catch (err) {
+      ctx.throw(400, err.message);
+    }
+  },
+
   // ── Morph link sync (documentId-based mapping) ───────────────────────────
 
   async getMorphLinks(ctx) {

package/server/src/routes/index.js

@@ -91,6 +91,9 @@ const adminRoutes = [
   { 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/profiles/:id/pause',   handler: 'syncMedia.pauseProfile',        config: { policies: [] } },
+  { method: 'POST',   path: '/media-sync/profiles/:id/resume',  handler: 'syncMedia.resumeProfile',       config: { policies: [] } },
+  { method: 'POST',   path: '/media-sync/profiles/:id/cancel',  handler: 'syncMedia.cancelProfile',       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: [] } },
@@ -110,6 +113,21 @@ const adminRoutes = [
   { 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: [] } },
+
+  // Bulk Transfer (one-click full pull / full push)
+  { method: 'POST', path: '/bulk-transfer/preview',         handler: 'bulkTransfer.preview', config: { policies: [] } },
+  { method: 'POST', path: '/bulk-transfer/start',           handler: 'bulkTransfer.start',   config: { policies: [] } },
+  { method: 'GET',  path: '/bulk-transfer/jobs',            handler: 'bulkTransfer.list',    config: { policies: [] } },
+  { method: 'GET',  path: '/bulk-transfer/jobs/:jobId',     handler: 'bulkTransfer.status',  config: { policies: [] } },
+  { method: 'POST', path: '/bulk-transfer/jobs/:jobId/next',    handler: 'bulkTransfer.next',   config: { policies: [] } },
+  { method: 'POST', path: '/bulk-transfer/jobs/:jobId/run-all', handler: 'bulkTransfer.runAll', config: { policies: [] } },
+  { method: 'POST', path: '/bulk-transfer/jobs/:jobId/pause',   handler: 'bulkTransfer.pause',  config: { policies: [] } },
+  { method: 'POST', path: '/bulk-transfer/jobs/:jobId/resume',  handler: 'bulkTransfer.resume', config: { policies: [] } },
+  { method: 'POST', path: '/bulk-transfer/jobs/:jobId/cancel',  handler: 'bulkTransfer.cancel', config: { policies: [] } },
+  { method: 'GET',  path: '/bulk-transfer/history',             handler: 'bulkTransfer.history',      config: { policies: [] } },
+  { method: 'POST', path: '/bulk-transfer/history/clear',       handler: 'bulkTransfer.clearHistory', config: { policies: [] } },
+  { method: 'POST', path: '/bulk-transfer/history/:historyId/restart', handler: 'bulkTransfer.restart', config: { policies: [] } },
+  { method: 'POST', path: '/bulk-transfer/history/:historyId/resume',  handler: 'bulkTransfer.resumeFromHistory', config: { policies: [] } },
 ];
 
 module.exports = {