strapi-content-sync-pro 1.0.2 → 1.0.3

package/server/src/services/sync.js

@@ -2,7 +2,7 @@
 
 const { fetchLocalRecords, fetchRemoteRecords } = require('../utils/fetcher');
 const { compareRecords } = require('../utils/comparator');
-const { applyLocal, applyRemote } = require('../utils/applier');
+const { applyLocal, applyRemote, deleteLocal, deleteRemote } = require('../utils/applier');
 
 const LAST_SYNC_STORE_KEY = 'last-sync-timestamps';
 
@@ -49,115 +49,165 @@ module.exports = ({ strapi }) => {
       const syncConfig = await syncConfigService.getSyncConfig();
       const enabledTypes = (syncConfig.contentTypes || []).filter((ct) => ct.enabled);
 
-      if (enabledTypes.length === 0) {
-        throw new Error('No content types configured for sync');
-      }
-
       // Pagination — remote + local fetches are chunked to keep memory bounded
       // for large datasets. Page size is a global setting tunable in the Sync tab.
       const globalExec = (await executionService.getGlobalSettings?.()) || {};
-      const pageSize = Number(globalExec.syncPageSize) || 100;
 
-      const timestamps = await getLastSyncTimestamps();
-      const conflictStrategy = syncConfig.conflictStrategy || 'latest';
-      const results = [];
+      const syncStatsService = plugin().service('syncStats');
+      const reportHandle = await syncStatsService.createRunReport({
+        runType: 'sync_now',
+        trigger: 'manual_sync_now',
+        contentTypes: enabledTypes.map((ct) => ct.uid),
+      });
 
-      for (const ctConfig of enabledTypes) {
-        const { uid, direction, fields } = ctConfig;
-        const lastSyncAt = timestamps[uid] || null;
-        const syncStartTime = new Date().toISOString();
+      try {
+        if (enabledTypes.length === 0) {
+          throw new Error('No content types configured for sync');
+        }
 
-        // Get field-level policies from active profile (if any)
-        const fieldPolicies = await syncProfilesService.getFieldPoliciesForContentType(uid);
+        const pageSize = Number(globalExec.syncPageSize) || 100;
 
-        try {
-          // Both sides are fetched in pages of `pageSize` records under the
-          // hood (see utils/fetcher.js). We aggregate per content-type because
-          // the comparator needs the full set to diff by syncId, but each
-          // network/DB call still only returns a bounded chunk.
-          const localRecords = await fetchLocalRecords(strapi, uid, { fields, lastSyncAt, pageSize });
-          const remoteRecords = await fetchRemoteRecords(remoteConfig, uid, { fields, lastSyncAt, pageSize });
-
-          const diff = compareRecords(localRecords, remoteRecords, {
-            direction,
-            conflictStrategy,
-          });
+        const timestamps = await getLastSyncTimestamps();
+        const conflictStrategy = syncConfig.conflictStrategy || 'latest';
+        const results = [];
+
+        for (const ctConfig of enabledTypes) {
+          const { uid, direction, fields } = ctConfig;
+          const lastSyncAt = timestamps[uid] || null;
+          const syncStartTime = new Date().toISOString();
 
-          let pushed = 0;
-          let pulled = 0;
-          let errors = 0;
-
-          // Apply field policies to records before pushing/pulling
-          for (const { local } of diff.toPush) {
-            try {
-              const filteredRecord = syncProfilesService.filterFieldsByPolicy(local, fieldPolicies, 'push');
-              await applyRemote(remoteConfig, uid, filteredRecord, fields);
-              pushed++;
-            } catch (err) {
-              errors++;
-              await logService.log({ action: 'push', contentType: uid, syncId: local.syncId, direction: 'push', status: 'error', message: err.message });
+          // Get field-level policies from active profile (if any)
+          const fieldPolicies = await syncProfilesService.getFieldPoliciesForContentType(uid);
+
+          try {
+            // Both sides are fetched in pages of `pageSize` records under the
+            // hood (see utils/fetcher.js). We aggregate per content-type because
+            // the comparator needs the full set to diff by syncId, but each
+            // network/DB call still only returns a bounded chunk.
+            const localRecords = await fetchLocalRecords(strapi, uid, { fields, lastSyncAt, pageSize });
+            const remoteRecords = await fetchRemoteRecords(remoteConfig, uid, { fields, lastSyncAt, pageSize });
+
+            const profileForOptions = await syncProfilesService.getActiveProfileForContentType(uid);
+            const syncDeletions = !!(profileForOptions?.syncDeletions);
+
+            const diff = compareRecords(localRecords, remoteRecords, {
+              direction,
+              conflictStrategy,
+              syncDeletions,
+            });
+
+            let pushed = 0;
+            let pulled = 0;
+            let errors = 0;
+
+            // Apply field policies to records before pushing/pulling
+            for (const { local } of diff.toPush) {
+              try {
+                const filteredRecord = syncProfilesService.filterFieldsByPolicy(local, fieldPolicies, 'push');
+                await applyRemote(remoteConfig, uid, filteredRecord, fields);
+                pushed++;
+              } catch (err) {
+                errors++;
+                await logService.log({ action: 'push', contentType: uid, syncId: local.syncId, direction: 'push', status: 'error', message: err.message });
+              }
             }
-          }
 
-          for (const { remote } of diff.toPull) {
-            try {
-              const filteredRecord = syncProfilesService.filterFieldsByPolicy(remote, fieldPolicies, 'pull');
-              await applyLocal(strapi, uid, filteredRecord, fields);
-              pulled++;
-            } catch (err) {
-              errors++;
-              await logService.log({ action: 'pull', contentType: uid, syncId: remote.syncId, direction: 'pull', status: 'error', message: err.message });
+            for (const { remote } of diff.toPull) {
+              try {
+                const filteredRecord = syncProfilesService.filterFieldsByPolicy(remote, fieldPolicies, 'pull');
+                await applyLocal(strapi, uid, filteredRecord, fields);
+                pulled++;
+              } catch (err) {
+                errors++;
+                await logService.log({ action: 'pull', contentType: uid, syncId: remote.syncId, direction: 'pull', status: 'error', message: err.message });
+              }
             }
-          }
 
-          for (const record of diff.toCreateRemote) {
-            try {
-              const filteredRecord = syncProfilesService.filterFieldsByPolicy(record, fieldPolicies, 'push');
-              await applyRemote(remoteConfig, uid, filteredRecord, fields);
-              pushed++;
-            } catch (err) {
-              errors++;
-              await logService.log({ action: 'create_remote', contentType: uid, syncId: record.syncId, direction: 'push', status: 'error', message: err.message });
+            for (const record of diff.toCreateRemote) {
+              try {
+                const filteredRecord = syncProfilesService.filterFieldsByPolicy(record, fieldPolicies, 'push');
+                await applyRemote(remoteConfig, uid, filteredRecord, fields);
+                pushed++;
+              } catch (err) {
+                errors++;
+                await logService.log({ action: 'create_remote', contentType: uid, syncId: record.syncId, direction: 'push', status: 'error', message: err.message });
+              }
             }
-          }
 
-          for (const record of diff.toCreateLocal) {
-            try {
-              const filteredRecord = syncProfilesService.filterFieldsByPolicy(record, fieldPolicies, 'pull');
-              await applyLocal(strapi, uid, filteredRecord, fields);
-              pulled++;
-            } catch (err) {
-              errors++;
-              await logService.log({ action: 'create_local', contentType: uid, syncId: record.syncId, direction: 'pull', status: 'error', message: err.message });
+            for (const record of diff.toCreateLocal) {
+              try {
+                const filteredRecord = syncProfilesService.filterFieldsByPolicy(record, fieldPolicies, 'pull');
+                await applyLocal(strapi, uid, filteredRecord, fields);
+                pulled++;
+              } catch (err) {
+                errors++;
+                await logService.log({ action: 'create_local', contentType: uid, syncId: record.syncId, direction: 'pull', status: 'error', message: err.message });
+              }
             }
-          }
 
-          await setLastSyncTimestamp(uid, syncStartTime);
+            for (const record of diff.toDeleteRemote) {
+              try {
+                await deleteRemote(remoteConfig, uid, record);
+                await logService.log({ action: 'delete_remote', contentType: uid, syncId: record.syncId, direction: 'push', status: 'success', message: `Deleted remote record ${record.syncId}` });
+              } catch (err) {
+                errors++;
+                await logService.log({ action: 'delete_remote', contentType: uid, syncId: record.syncId, direction: 'push', status: 'error', message: err.message });
+              }
+            }
 
-          const summary = { uid, pushed, pulled, errors, hasFieldPolicies: !!fieldPolicies };
-          results.push(summary);
+            for (const record of diff.toDeleteLocal) {
+              try {
+                await deleteLocal(strapi, uid, record);
+                await logService.log({ action: 'delete_local', contentType: uid, syncId: record.syncId, direction: 'pull', status: 'success', message: `Deleted local record ${record.syncId}` });
+              } catch (err) {
+                errors++;
+                await logService.log({ action: 'delete_local', contentType: uid, syncId: record.syncId, direction: 'pull', status: 'error', message: err.message });
+              }
+            }
 
-          await logService.log({
-            action: 'sync_complete',
-            contentType: uid,
-            direction,
-            status: errors > 0 ? 'partial' : 'success',
-            message: `Pushed: ${pushed}, Pulled: ${pulled}, Errors: ${errors}${fieldPolicies ? ' (with field policies)' : ''}`,
-            details: summary,
-          });
-        } catch (err) {
-          results.push({ uid, error: err.message });
-          await logService.log({
-            action: 'sync_error',
-            contentType: uid,
-            direction,
-            status: 'error',
-            message: err.message,
-          });
+            await setLastSyncTimestamp(uid, syncStartTime);
+
+            const summary = { uid, pushed, pulled, errors, hasFieldPolicies: !!fieldPolicies };
+            results.push(summary);
+
+            await logService.log({
+              action: 'sync_complete',
+              contentType: uid,
+              direction,
+              status: errors > 0 ? 'partial' : 'success',
+              message: `Pushed: ${pushed}, Pulled: ${pulled}, Errors: ${errors}${fieldPolicies ? ' (with field policies)' : ''}`,
+              details: summary,
+            });
+          } catch (err) {
+            results.push({ uid, error: err.message });
+            await logService.log({
+              action: 'sync_error',
+              contentType: uid,
+              direction,
+              status: 'error',
+              message: err.message,
+            });
+          }
         }
-      }
 
-      return { syncedAt: new Date().toISOString(), results };
+        const response = { syncedAt: new Date().toISOString(), results };
+        await syncStatsService.completeRunReport(reportHandle.reportId, {
+          status: 'success',
+          summary: response,
+        });
+        await plugin().service('syncLog').applyRetention({ maxLogs: globalExec.maxLogEntries });
+        await syncStatsService.applyRetention({ maxReports: globalExec.maxReportEntries });
+        return response;
+      } catch (err) {
+        await syncStatsService.completeRunReport(reportHandle.reportId, {
+          status: 'error',
+          summary: null,
+          error: err.message,
+        });
+        await plugin().service('syncLog').applyRetention({ maxLogs: globalExec.maxLogEntries });
+        await syncStatsService.applyRetention({ maxReports: globalExec.maxReportEntries });
+        throw err;
+      }
     },
 
     /**
@@ -191,6 +241,7 @@ module.exports = ({ strapi }) => {
 
       const direction = profile?.direction || ctConfig.direction || 'both';
       const conflictStrategy = profile?.conflictStrategy || syncConfig.conflictStrategy || 'latest';
+      const syncDeletions = !!(profile?.syncDeletions);
       const fields = ctConfig.fields || [];
 
       // Field-level policies: prefer the policies on the provided profile,
@@ -222,7 +273,7 @@ module.exports = ({ strapi }) => {
         const localRecords = await fetchLocalRecords(strapi, uid, { fields, lastSyncAt, pageSize });
         const remoteRecords = await fetchRemoteRecords(remoteConfig, uid, { fields, lastSyncAt, pageSize });
 
-        const diff = compareRecords(localRecords, remoteRecords, { direction, conflictStrategy });
+        const diff = compareRecords(localRecords, remoteRecords, { direction, conflictStrategy, syncDeletions });
 
         for (const { local } of diff.toPush) {
           try {
@@ -268,6 +319,26 @@ module.exports = ({ strapi }) => {
           }
         }
 
+        for (const record of diff.toDeleteRemote) {
+          try {
+            await deleteRemote(remoteConfig, uid, record);
+            await logService.log({ action: 'delete_remote', contentType: uid, syncId: record.syncId, direction: 'push', status: 'success', message: `Deleted remote record ${record.syncId}` });
+          } catch (err) {
+            errors++;
+            await logService.log({ action: 'delete_remote', contentType: uid, syncId: record.syncId, direction: 'push', status: 'error', message: err.message });
+          }
+        }
+
+        for (const record of diff.toDeleteLocal) {
+          try {
+            await deleteLocal(strapi, uid, record);
+            await logService.log({ action: 'delete_local', contentType: uid, syncId: record.syncId, direction: 'pull', status: 'success', message: `Deleted local record ${record.syncId}` });
+          } catch (err) {
+            errors++;
+            await logService.log({ action: 'delete_local', contentType: uid, syncId: record.syncId, direction: 'pull', status: 'error', message: err.message });
+          }
+        }
+
         await setLastSyncTimestamp(uid, syncStartTime);
 
         const summary = {
@@ -352,32 +423,47 @@ module.exports = ({ strapi }) => {
      * Step 9 — Receive a record pushed from a remote instance.
      * Now supports field-level policies.
      */
-    async receiveRecord(uid, data, syncId) {
+    async receiveRecord(uid, data, syncId, isDelete = false, documentId = null) {
       const logService = plugin().service('syncLog');
       const syncProfilesService = plugin().service('syncProfiles');
 
-      // Get field-level policies from active profile (if any)
-      const fieldPolicies = await syncProfilesService.getFieldPoliciesForContentType(uid);
-      const filteredData = syncProfilesService.filterFieldsByPolicy(data, fieldPolicies, 'pull');
+      const key = documentId || syncId;
 
       try {
-        await applyLocal(strapi, uid, { ...filteredData, syncId }, []);
+        if (isDelete) {
+          await deleteLocal(strapi, uid, { documentId, syncId });
+          await logService.log({
+            action: 'receive_delete',
+            contentType: uid,
+            syncId: key,
+            direction: 'pull',
+            status: 'success',
+            message: `Delete received for ${key} from remote`,
+          });
+          return { success: true, deleted: true };
+        }
+
+        // Get field-level policies from active profile (if any)
+        const fieldPolicies = await syncProfilesService.getFieldPoliciesForContentType(uid);
+        const filteredData = syncProfilesService.filterFieldsByPolicy(data, fieldPolicies, 'pull');
+
+        await applyLocal(strapi, uid, { ...filteredData, documentId, syncId }, []);
 
         await logService.log({
           action: 'receive',
           contentType: uid,
-          syncId,
+          syncId: key,
           direction: 'pull',
           status: 'success',
-          message: `Record ${syncId} received from remote${fieldPolicies ? ' (with field policies)' : ''}`,
+          message: `Record ${key} received from remote${fieldPolicies ? ' (with field policies)' : ''}`,
         });
 
         return { success: true };
       } catch (err) {
         await logService.log({
-          action: 'receive',
+          action: isDelete ? 'receive_delete' : 'receive',
           contentType: uid,
-          syncId,
+          syncId: key,
           direction: 'pull',
           status: 'error',
           message: err.message,

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';
 }