strapi-content-sync-pro 1.0.2 → 1.0.4

package/server/src/utils/applier.js

@@ -1,31 +1,60 @@
 'use strict';
 
+const { strapi: strapiPackageConfig = {} } = require('../../../package.json');
 const { generateSignature } = require('./hmac');
 const { markAsRemoteUpdate } = require('./sync-guard');
 
+const PLUGIN_ID = strapiPackageConfig.name || 'strapi-content-sync-pro';
+
 /**
  * Apply a record received from a remote instance to the local database.
+ *
+ * Strapi v5 identifies entities by `documentId` (stable across instances),
+ * while some legacy plugin installs add a custom `syncId` attribute. Prefer
+ * `documentId` and fall back to `syncId` for back-compat.
  */
 async function applyLocal(strapi, uid, record, fields) {
   const data = filterFields(record, fields);
-  const syncId = record.syncId;
+  const documentId = record.documentId || null;
+  const syncId = record.syncId || null;
+  const key = documentId || syncId;
 
   // Mark so the afterCreate/afterUpdate hook skips re-pushing
-  markAsRemoteUpdate(`${uid}:${syncId}`);
+  if (key) markAsRemoteUpdate(`${uid}:${key}`);
 
-  const existing = await strapi.documents(uid).findMany({
-    filters: { syncId },
-    limit: 1,
-  });
+  let existingDocumentId = null;
+
+  if (documentId) {
+    try {
+      const found = await strapi.documents(uid).findOne({ documentId });
+      if (found) existingDocumentId = found.documentId || documentId;
+    } catch {
+      // fall through and try syncId lookup
+    }
+  }
+
+  if (!existingDocumentId && syncId) {
+    try {
+      const existing = await strapi.documents(uid).findMany({
+        filters: { syncId },
+        limit: 1,
+      });
+      if (existing && existing.length > 0) existingDocumentId = existing[0].documentId;
+    } catch {
+      // ignore — treat as create
+    }
+  }
 
-  if (existing && existing.length > 0) {
+  if (existingDocumentId) {
     return strapi.documents(uid).update({
-      documentId: existing[0].documentId,
+      documentId: existingDocumentId,
       data,
     });
   }
 
-  data.syncId = syncId;
+  // Create: preserve documentId so the two instances share identity
+  if (documentId) data.documentId = documentId;
+  if (syncId) data.syncId = syncId;
   return strapi.documents(uid).create({ data });
 }
 
@@ -34,12 +63,13 @@ async function applyLocal(strapi, uid, record, fields) {
  */
 async function applyRemote(remoteConfig, uid, record, fields) {
   const { baseUrl, apiToken, sharedSecret } = remoteConfig;
-  const url = new URL('/strapi-content-sync-pro/receive', baseUrl);
+  const url = new URL(`/api/${PLUGIN_ID}/receive`, baseUrl);
 
   const body = {
     uid,
     data: filterFields(record, fields),
-    syncId: record.syncId,
+    documentId: record.documentId || null,
+    syncId: record.syncId || null,
   };
 
   const timestamp = Date.now().toString();
@@ -66,14 +96,18 @@ async function applyRemote(remoteConfig, uid, record, fields) {
 
 /**
  * Return only the requested fields from a record, stripping Strapi internals.
+ *
+ * `documentId` and `syncId` are preserved (when present) so the remote side
+ * can upsert against the same cross-instance identity.
  */
 function filterFields(record, fields) {
   if (!fields || fields.length === 0) {
     const {
-      id, documentId, createdAt, updatedAt, publishedAt,
+      id, createdAt, updatedAt, publishedAt,
       createdBy, updatedBy, locale, localizations,
       ...data
     } = record;
+    // Keep documentId/syncId on the payload; strip createdAt/updatedAt/etc.
     return data;
   }
 
@@ -83,7 +117,80 @@ function filterFields(record, fields) {
       data[field] = record[field];
     }
   }
+  if (record.documentId !== undefined && data.documentId === undefined) {
+    data.documentId = record.documentId;
+  }
+  if (record.syncId !== undefined && data.syncId === undefined) {
+    data.syncId = record.syncId;
+  }
   return data;
 }
 
-module.exports = { applyLocal, applyRemote, filterFields };
+async function deleteLocal(strapi, uid, record) {
+  const documentId = record?.documentId || null;
+  const syncId = record?.syncId || null;
+  const key = documentId || syncId;
+  if (!key) return { skipped: true, reason: 'missing_documentId_and_syncId' };
+
+  let existingDocumentId = null;
+
+  if (documentId) {
+    try {
+      const found = await strapi.documents(uid).findOne({ documentId });
+      if (found) existingDocumentId = found.documentId || documentId;
+    } catch { /* ignore */ }
+  }
+
+  if (!existingDocumentId && syncId) {
+    try {
+      const existing = await strapi.documents(uid).findMany({
+        filters: { syncId },
+        limit: 1,
+      });
+      if (existing && existing.length > 0) existingDocumentId = existing[0].documentId;
+    } catch { /* ignore */ }
+  }
+
+  if (!existingDocumentId) {
+    return { skipped: true, reason: 'not_found' };
+  }
+
+  markAsRemoteUpdate(`${uid}:${key}`);
+  await strapi.documents(uid).delete({ documentId: existingDocumentId });
+  return { deleted: true };
+}
+
+async function deleteRemote(remoteConfig, uid, record) {
+  const { baseUrl, apiToken, sharedSecret } = remoteConfig;
+  const url = new URL(`/api/${PLUGIN_ID}/receive`, baseUrl);
+
+  const body = {
+    uid,
+    documentId: record?.documentId || null,
+    syncId: record?.syncId || null,
+    delete: true,
+  };
+
+  const timestamp = Date.now().toString();
+  const signature = generateSignature(body, sharedSecret, timestamp);
+
+  const response = await fetch(url.toString(), {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${apiToken}`,
+      'Content-Type': 'application/json',
+      'x-sync-signature': signature,
+      'x-sync-timestamp': timestamp,
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Remote delete failed for ${uid}: ${response.status} – ${text}`);
+  }
+
+  return response.json();
+}
+
+module.exports = { applyLocal, applyRemote, deleteLocal, deleteRemote, filterFields };

package/server/src/utils/comparator.js

@@ -8,26 +8,33 @@
  * @param {Object} options
  * @param {string} options.direction        – "push" | "pull" | "both"
  * @param {string} options.conflictStrategy – "latest" | "local_wins" | "remote_wins"
- * @returns {{ toPush, toPull, toCreateRemote, toCreateLocal }}
+ * @param {boolean} options.syncDeletions   – propagate missing records as deletions
+ * @returns {{ toPush, toPull, toCreateRemote, toCreateLocal, toDeleteRemote, toDeleteLocal }}
  */
 function compareRecords(localRecords, remoteRecords, options = {}) {
-  const { direction = 'both', conflictStrategy = 'latest' } = options;
+  const { direction = 'both', conflictStrategy = 'latest', syncDeletions = false } = options;
 
   const result = {
     toPush: [],
     toPull: [],
     toCreateRemote: [],
     toCreateLocal: [],
+    toDeleteRemote: [],
+    toDeleteLocal: [],
   };
 
   const localBySyncId = new Map();
   const remoteBySyncId = new Map();
 
+  const keyOf = (r) => r && (r.documentId || r.syncId);
+
   for (const r of localRecords) {
-    if (r.syncId) localBySyncId.set(r.syncId, r);
+    const k = keyOf(r);
+    if (k) localBySyncId.set(k, r);
   }
   for (const r of remoteRecords) {
-    if (r.syncId) remoteBySyncId.set(r.syncId, r);
+    const k = keyOf(r);
+    if (k) remoteBySyncId.set(k, r);
   }
 
   // Records that exist on both sides
@@ -43,7 +50,11 @@ function compareRecords(localRecords, remoteRecords, options = {}) {
         result.toPull.push({ local: localRecord, remote: remoteRecord });
       }
     } else if (direction === 'push' || direction === 'both') {
-      result.toCreateRemote.push(localRecord);
+      if (syncDeletions && direction !== 'both') {
+        result.toDeleteRemote.push(localRecord);
+      } else {
+        result.toCreateRemote.push(localRecord);
+      }
     }
   }
 
@@ -51,7 +62,12 @@ function compareRecords(localRecords, remoteRecords, options = {}) {
   for (const [syncId] of remoteBySyncId) {
     if (!localBySyncId.has(syncId)) {
       if (direction === 'pull' || direction === 'both') {
-        result.toCreateLocal.push(remoteBySyncId.get(syncId));
+        const remoteRecord = remoteBySyncId.get(syncId);
+        if (syncDeletions && direction !== 'both') {
+          result.toDeleteLocal.push(remoteRecord);
+        } else {
+          result.toCreateLocal.push(remoteRecord);
+        }
       }
     }
   }

package/server/src/utils/fetcher.js

@@ -19,7 +19,7 @@ async function fetchLocalPage(strapi, uid, { fields, lastSyncAt, page = 1, pageS
   }
 
   if (fields && fields.length > 0) {
-    params.fields = [...new Set([...fields, 'syncId', 'updatedAt'])];
+    params.fields = [...new Set([...fields, 'documentId', 'syncId', 'updatedAt'])];
   }
 
   const records = (await strapi.documents(uid).findMany(params)) || [];
@@ -37,7 +37,7 @@ async function fetchRemotePage(remoteConfig, uid, { fields, lastSyncAt, page = 1
   const url = new URL(`/api/${pluralName}`, baseUrl);
 
   if (fields && fields.length > 0) {
-    const allFields = [...new Set([...fields, 'syncId', 'updatedAt'])];
+    const allFields = [...new Set([...fields, 'documentId', 'syncId', 'updatedAt'])];
     allFields.forEach((f, i) => {
       url.searchParams.set(`fields[${i}]`, f);
     });
@@ -123,10 +123,19 @@ async function fetchRemoteRecords(remoteConfig, uid, options = {}) {
  * e.g. "api::product.product" → "products"
  */
 function uidToPluralEndpoint(uid) {
+  const contentType = global.strapi?.contentTypes?.[uid];
+  const configuredPlural = contentType?.info?.pluralName;
+  if (configuredPlural) {
+    return configuredPlural;
+  }
+
   const parts = uid.split('.');
   const modelName = parts[parts.length - 1];
   if (modelName.endsWith('s')) return modelName;
   if (modelName.endsWith('y')) return modelName.slice(0, -1) + 'ies';
+  if (modelName.endsWith('ch') || modelName.endsWith('sh') || modelName.endsWith('x') || modelName.endsWith('z')) {
+    return modelName + 'es';
+  }
   return modelName + 's';
 }