strapi-content-sync-pro 1.0.1 → 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,327 @@ 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;
+
+        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();
+
+          // 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 });
+              }
+            }
 
-        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,
-          });
+            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 });
+              }
+            }
 
-          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 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 { 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.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.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.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.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.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 = { 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,
+            });
           }
+        }
+
+        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;
+      }
+    },
 
-          await setLastSyncTimestamp(uid, syncStartTime);
+    /**
+     * Sync a single content type using a given profile.
+     * Called by the execution service (on-demand / scheduled / live runs).
+     *
+     * options:
+     *   - profile: sync profile { contentType, direction, conflictStrategy, isSimple, fieldPolicies }
+     *   - syncDependencies: boolean (currently informational; dependency resolution handled upstream)
+     *   - dependencyDepth: number
+     */
+    async syncContentType(uid, options = {}) {
+      if (!uid) {
+        throw new Error('Content type uid is required');
+      }
 
-          const summary = { uid, pushed, pulled, errors, hasFieldPolicies: !!fieldPolicies };
-          results.push(summary);
+      const logService = plugin().service('syncLog');
+      const configService = plugin().service('config');
+      const syncConfigService = plugin().service('syncConfig');
+      const syncProfilesService = plugin().service('syncProfiles');
+      const executionService = plugin().service('syncExecution');
 
-          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,
-          });
+      const remoteConfig = await configService.getConfig({ safe: false });
+      if (!remoteConfig || !remoteConfig.baseUrl) {
+        throw new Error('Remote server not configured');
+      }
+
+      const { profile } = options;
+      const syncConfig = await syncConfigService.getSyncConfig();
+      const ctConfig = (syncConfig.contentTypes || []).find((ct) => ct.uid === uid) || { uid, fields: [] };
+
+      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,
+      // otherwise fall back to the active profile for the content type.
+      let fieldPolicies = null;
+      if (profile) {
+        if (!profile.isSimple && Array.isArray(profile.fieldPolicies) && profile.fieldPolicies.length > 0) {
+          fieldPolicies = {};
+          for (const fp of profile.fieldPolicies) {
+            fieldPolicies[fp.field] = fp.direction;
+          }
         }
+      } else {
+        fieldPolicies = await syncProfilesService.getFieldPoliciesForContentType(uid);
       }
 
-      return { syncedAt: new Date().toISOString(), results };
+      const globalExec = (await executionService.getGlobalSettings?.()) || {};
+      const pageSize = Number(globalExec.syncPageSize) || 100;
+
+      const timestamps = await getLastSyncTimestamps();
+      const lastSyncAt = timestamps[uid] || null;
+      const syncStartTime = new Date().toISOString();
+
+      let pushed = 0;
+      let pulled = 0;
+      let errors = 0;
+
+      try {
+        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, syncDeletions });
+
+        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 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.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 = {
+          uid,
+          pushed,
+          pulled,
+          errors,
+          hasFieldPolicies: !!fieldPolicies,
+          profile: profile ? { id: profile.id, name: profile.name } : null,
+        };
+
+        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,
+        });
+
+        return { syncedAt: new Date().toISOString(), ...summary };
+      } catch (err) {
+        await logService.log({
+          action: 'sync_error',
+          contentType: uid,
+          direction,
+          status: 'error',
+          message: err.message,
+        });
+        throw err;
+      }
     },
 
     /**
@@ -211,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 };