strapi-content-sync-pro 1.0.2 → 1.0.4

package/server/src/services/sync-profiles.js

@@ -38,6 +38,29 @@ module.exports = ({ strapi }) => {
   const VALID_DIRECTIONS = ['push', 'pull', 'both', 'none'];
   const VALID_CONFLICT_STRATEGIES = ['latest', 'local_wins', 'remote_wins'];
 
+  async function getSyncMode() {
+    const configService = strapi.plugin('strapi-content-sync-pro').service('config');
+    const config = await configService.getConfig({ safe: false });
+    return config?.syncMode || 'paired';
+  }
+
+  function normalizeProfileForMode(profile, syncMode) {
+    if (syncMode !== 'single_side') return profile;
+
+    const next = { ...profile };
+    next.direction = 'pull';
+
+    if (!next.isSimple && Array.isArray(next.fieldPolicies)) {
+      next.fieldPolicies = next.fieldPolicies.map((fp) => {
+        if (fp.direction === 'push') return { ...fp, direction: 'pull' };
+        if (fp.direction === 'both') return { ...fp, direction: 'pull' };
+        return fp;
+      });
+    }
+
+    return next;
+  }
+
   return {
     /**
      * Get all sync profiles
@@ -45,7 +68,33 @@ module.exports = ({ strapi }) => {
     async getProfiles() {
       const store = getStore();
       const data = await store.get({ key: STORE_KEY });
-      return data || [];
+      const profiles = data || [];
+      const syncMode = await getSyncMode();
+      if (syncMode !== 'single_side') return profiles;
+
+      let changed = false;
+      const normalized = profiles.map((p) => {
+        if (p.direction === 'pull') return p;
+        changed = true;
+        return {
+          ...p,
+          direction: 'pull',
+          syncDeletions: !!p.syncDeletions,
+          fieldPolicies: Array.isArray(p.fieldPolicies)
+            ? p.fieldPolicies.map((fp) => ({
+                ...fp,
+                direction: fp.direction === 'none' ? 'none' : 'pull',
+              }))
+            : p.fieldPolicies,
+          updatedAt: new Date().toISOString(),
+        };
+      });
+
+      if (changed) {
+        await store.set({ key: STORE_KEY, value: normalized });
+      }
+
+      return normalized;
     },
 
     /**
@@ -53,7 +102,10 @@ module.exports = ({ strapi }) => {
      */
     async getProfile(id) {
       const profiles = await this.getProfiles();
-      return profiles.find((p) => p.id === id) || null;
+      const profile = profiles.find((p) => p.id === id) || null;
+      if (!profile) return null;
+      const syncMode = await getSyncMode();
+      return normalizeProfileForMode(profile, syncMode);
     },
 
     /**
@@ -61,7 +113,11 @@ module.exports = ({ strapi }) => {
      */
     async getActiveProfileForContentType(contentTypeUid) {
       const profiles = await this.getProfiles();
-      return profiles.find((p) => p.contentType === contentTypeUid && p.isActive) || null;
+      const active = profiles.find((p) => p.contentType === contentTypeUid && p.isActive) || null;
+      if (!active) return null;
+
+      const syncMode = await getSyncMode();
+      return normalizeProfileForMode(active, syncMode);
     },
 
     /**
@@ -69,7 +125,10 @@ module.exports = ({ strapi }) => {
      */
     async getProfilesForContentType(contentTypeUid) {
       const profiles = await this.getProfiles();
-      return profiles.filter((p) => p.contentType === contentTypeUid);
+      const syncMode = await getSyncMode();
+      return profiles
+        .filter((p) => p.contentType === contentTypeUid)
+        .map((p) => normalizeProfileForMode(p, syncMode));
     },
 
     /**
@@ -91,6 +150,7 @@ module.exports = ({ strapi }) => {
           contentType: contentTypeUid,
           direction: 'push',
           conflictStrategy: 'local_wins',
+          syncDeletions: false,
           isActive: false,
           isSimple: true,
           fieldPolicies: [],
@@ -100,6 +160,7 @@ module.exports = ({ strapi }) => {
           contentType: contentTypeUid,
           direction: 'pull',
           conflictStrategy: 'remote_wins',
+          syncDeletions: false,
           isActive: false,
           isSimple: true,
           fieldPolicies: [],
@@ -109,6 +170,7 @@ module.exports = ({ strapi }) => {
           contentType: contentTypeUid,
           direction: 'both',
           conflictStrategy: 'latest',
+          syncDeletions: false,
           isActive: true, // Default active profile
           isSimple: true,
           fieldPolicies: [],
@@ -166,6 +228,7 @@ module.exports = ({ strapi }) => {
         contentType: profileData.contentType,
         direction: profileData.direction || 'both',
         conflictStrategy: profileData.conflictStrategy || 'latest',
+        syncDeletions: !!profileData.syncDeletions,
         isActive: profileData.isActive || false,
         isSimple: profileData.isSimple !== false, // Default to simple mode
         fieldPolicies: (profileData.fieldPolicies || []).map((fp) => ({
@@ -176,6 +239,17 @@ module.exports = ({ strapi }) => {
         updatedAt: new Date().toISOString(),
       };
 
+      const syncMode = await getSyncMode();
+      if (syncMode === 'single_side') {
+        newProfile.direction = 'pull';
+        if (!newProfile.isSimple && Array.isArray(newProfile.fieldPolicies)) {
+          newProfile.fieldPolicies = newProfile.fieldPolicies.map((fp) => ({
+            ...fp,
+            direction: fp.direction === 'none' ? 'none' : 'pull',
+          }));
+        }
+      }
+
       // If this profile is set as active, deactivate others for same content type
       if (newProfile.isActive) {
         profiles.forEach((p) => {
@@ -238,11 +312,17 @@ module.exports = ({ strapi }) => {
       const updatedProfile = {
         ...profiles[index],
         ...updates,
+        syncDeletions: updates.syncDeletions !== undefined ? !!updates.syncDeletions : profiles[index].syncDeletions,
         id: profiles[index].id, // prevent id change
         createdAt: profiles[index].createdAt, // preserve creation date
         updatedAt: new Date().toISOString(),
       };
 
+      const syncMode = await getSyncMode();
+      if (syncMode === 'single_side') {
+        updatedProfile.direction = 'pull';
+      }
+
       if (updates.fieldPolicies) {
         updatedProfile.fieldPolicies = updates.fieldPolicies.map((fp) => ({
           field: fp.field,
@@ -250,6 +330,13 @@ module.exports = ({ strapi }) => {
         }));
       }
 
+      if (syncMode === 'single_side' && !updatedProfile.isSimple && Array.isArray(updatedProfile.fieldPolicies)) {
+        updatedProfile.fieldPolicies = updatedProfile.fieldPolicies.map((fp) => ({
+          ...fp,
+          direction: fp.direction === 'none' ? 'none' : 'pull',
+        }));
+      }
+
       profiles[index] = updatedProfile;
       await store.set({ key: STORE_KEY, value: profiles });
 
@@ -305,6 +392,7 @@ module.exports = ({ strapi }) => {
       return this.createProfile({
         ...presetConfig,
         contentType: contentTypeUid,
+        syncDeletions: false,
         isSimple: true,
         isActive: false,
         fieldPolicies: [],

package/server/src/services/sync-stats.js

@@ -0,0 +1,353 @@
+'use strict';
+
+const { uidToPluralEndpoint } = require('../utils/fetcher');
+
+const RUN_REPORT_UID = 'plugin::strapi-content-sync-pro.sync-run-report';
+
+module.exports = ({ strapi }) => {
+  function plugin() {
+    return strapi.plugin('strapi-content-sync-pro');
+  }
+
+  // Strapi upload's polymorphic join table name differs across versions
+  // (`files_related_morphs` on older builds, `files_related_mph` on v5).
+  // Resolve it from ORM metadata so stats work on both.
+  let _morphTableCache = null;
+  function resolveMorphTable() {
+    if (_morphTableCache) return _morphTableCache;
+    const candidates = [];
+    try {
+      const attr = strapi.db?.metadata?.get?.('plugin::upload.file')?.attributes?.related;
+      if (attr?.joinTable?.name) candidates.push(attr.joinTable.name);
+      if (attr?.pivotTable) candidates.push(attr.pivotTable);
+    } catch {
+      // ignore — fall back below
+    }
+    candidates.push('files_related_mph', 'files_related_morphs');
+    _morphTableCache = candidates.find((n) => !!n) || 'files_related_mph';
+    return _morphTableCache;
+  }
+
+  async function getEnabledContentTypes() {
+    const syncConfig = await plugin().service('syncConfig').getSyncConfig();
+    return (syncConfig.contentTypes || []).filter((ct) => ct.enabled).map((ct) => ct.uid);
+  }
+
+  async function getMediaStatsLocal() {
+    const [count, newest] = await Promise.all([
+      strapi.db.query('plugin::upload.file').count(),
+      strapi.db.query('plugin::upload.file').findMany({
+        orderBy: { updatedAt: 'desc' },
+        limit: 1,
+        select: ['updatedAt'],
+      }),
+    ]);
+
+    const morphTable = resolveMorphTable();
+    const [morphCount, newestMorph] = await Promise.all([
+      strapi.db.connection(morphTable).count({ id: 'id' }).first().then((r) => Number(r?.id || 0)).catch(() => 0),
+      strapi.db.connection(morphTable).orderBy('id', 'desc').first().catch(() => null),
+    ]);
+
+    return {
+      fileCount: Number(count || 0),
+      fileNewestUpdatedAt: newest?.[0]?.updatedAt || null,
+      morphCount: Number(morphCount || 0),
+      morphNewestUpdatedAt: newestMorph?.created_at || newestMorph?.updated_at || null,
+      error: null,
+    };
+  }
+
+  async function getMediaStatsRemote(remoteConfig) {
+    const { baseUrl, apiToken } = remoteConfig || {};
+    if (!baseUrl || !apiToken) {
+      return {
+        fileCount: null,
+        fileNewestUpdatedAt: null,
+        morphCount: null,
+        morphNewestUpdatedAt: null,
+        error: 'Remote server is not configured',
+      };
+    }
+
+    try {
+      const countUrl = new URL('/api/upload/files', baseUrl);
+      countUrl.searchParams.set('pagination[page]', '1');
+      countUrl.searchParams.set('pagination[pageSize]', '1');
+      countUrl.searchParams.set('fields[0]', 'updatedAt');
+      const countRes = await fetch(countUrl.toString(), {
+        method: 'GET',
+        headers: { Authorization: `Bearer ${apiToken}`, 'Content-Type': 'application/json' },
+      });
+      if (!countRes.ok) {
+        return { fileCount: null, fileNewestUpdatedAt: null, morphCount: null, morphNewestUpdatedAt: null, error: `Remote media fetch failed (${countRes.status})` };
+      }
+      const countBody = await countRes.json();
+      const fileCount = countBody?.meta?.pagination?.total ?? null;
+
+      const newestUrl = new URL('/api/upload/files', baseUrl);
+      newestUrl.searchParams.set('pagination[page]', '1');
+      newestUrl.searchParams.set('pagination[pageSize]', '1');
+      newestUrl.searchParams.set('sort', 'updatedAt:desc');
+      newestUrl.searchParams.set('fields[0]', 'updatedAt');
+      const newestRes = await fetch(newestUrl.toString(), {
+        method: 'GET',
+        headers: { Authorization: `Bearer ${apiToken}`, 'Content-Type': 'application/json' },
+      });
+      if (!newestRes.ok) {
+        return { fileCount, fileNewestUpdatedAt: null, morphCount: null, morphNewestUpdatedAt: null, error: `Remote media newest fetch failed (${newestRes.status})` };
+      }
+
+      const newestBody = await newestRes.json();
+      const fileNewestUpdatedAt = newestBody?.data?.[0]?.updatedAt || null;
+
+      // Morph rows are internal DB relations; not exposed by core upload REST.
+      return {
+        fileCount,
+        fileNewestUpdatedAt,
+        morphCount: null,
+        morphNewestUpdatedAt: null,
+        error: null,
+      };
+    } catch (err) {
+      return { fileCount: null, fileNewestUpdatedAt: null, morphCount: null, morphNewestUpdatedAt: null, error: err.message };
+    }
+  }
+
+  async function fetchRemoteStats(remoteConfig, uid) {
+    const { baseUrl, apiToken } = remoteConfig || {};
+    if (!baseUrl || !apiToken) {
+      return { count: null, newestUpdatedAt: null, error: 'Remote server is not configured' };
+    }
+
+    const endpoint = uidToPluralEndpoint(uid);
+
+    try {
+      const countUrl = new URL(`/api/${endpoint}`, baseUrl);
+      countUrl.searchParams.set('pagination[page]', '1');
+      countUrl.searchParams.set('pagination[pageSize]', '1');
+      countUrl.searchParams.set('fields[0]', 'updatedAt');
+      const countRes = await fetch(countUrl.toString(), {
+        method: 'GET',
+        headers: { Authorization: `Bearer ${apiToken}`, 'Content-Type': 'application/json' },
+      });
+      if (!countRes.ok) {
+        return { count: null, newestUpdatedAt: null, error: `Remote count fetch failed (${countRes.status})` };
+      }
+      const countBody = await countRes.json();
+      const count = countBody?.meta?.pagination?.total ?? null;
+
+      const newestUrl = new URL(`/api/${endpoint}`, baseUrl);
+      newestUrl.searchParams.set('pagination[page]', '1');
+      newestUrl.searchParams.set('pagination[pageSize]', '1');
+      newestUrl.searchParams.set('sort', 'updatedAt:desc');
+      newestUrl.searchParams.set('fields[0]', 'updatedAt');
+      const newestRes = await fetch(newestUrl.toString(), {
+        method: 'GET',
+        headers: { Authorization: `Bearer ${apiToken}`, 'Content-Type': 'application/json' },
+      });
+      if (!newestRes.ok) {
+        return { count, newestUpdatedAt: null, error: `Remote newest fetch failed (${newestRes.status})` };
+      }
+
+      const newestBody = await newestRes.json();
+      const newestUpdatedAt = newestBody?.data?.[0]?.updatedAt || null;
+      return { count, newestUpdatedAt, error: null };
+    } catch (err) {
+      return { count: null, newestUpdatedAt: null, error: err.message };
+    }
+  }
+
+  function whereNewest(localTs, remoteTs) {
+    if (!localTs && !remoteTs) return 'equal';
+    if (localTs && !remoteTs) return 'local';
+    if (!localTs && remoteTs) return 'remote';
+    const l = new Date(localTs).getTime();
+    const r = new Date(remoteTs).getTime();
+    if (l === r) return 'equal';
+    return l > r ? 'local' : 'remote';
+  }
+
+  return {
+    async collectSnapshot({ contentTypes } = {}) {
+      const configService = plugin().service('config');
+      const remoteConfig = await configService.getConfig({ safe: false });
+      const targets = Array.isArray(contentTypes) && contentTypes.length > 0
+        ? contentTypes
+        : await getEnabledContentTypes();
+
+      const rows = [];
+      for (const uid of targets) {
+        let localCount = null;
+        let localNewestUpdatedAt = null;
+        let localError = null;
+        try {
+          localCount = await strapi.documents(uid).count({});
+          const newest = await strapi.documents(uid).findMany({
+            sort: { updatedAt: 'desc' },
+            limit: 1,
+            fields: ['updatedAt'],
+          });
+          localNewestUpdatedAt = newest?.[0]?.updatedAt || null;
+        } catch (err) {
+          localError = err.message;
+        }
+
+        const remote = await fetchRemoteStats(remoteConfig, uid);
+        rows.push({
+          uid,
+          type: 'content',
+          localCount,
+          remoteCount: remote.count,
+          localNewestUpdatedAt,
+          remoteNewestUpdatedAt: remote.newestUpdatedAt,
+          newestSide: whereNewest(localNewestUpdatedAt, remote.newestUpdatedAt),
+          localError,
+          remoteError: remote.error,
+        });
+      }
+
+      const localMedia = await getMediaStatsLocal();
+      const remoteMedia = await getMediaStatsRemote(remoteConfig);
+      rows.push({
+        uid: 'plugin::upload.file',
+        type: 'media_file',
+        localCount: localMedia.fileCount,
+        remoteCount: remoteMedia.fileCount,
+        localNewestUpdatedAt: localMedia.fileNewestUpdatedAt,
+        remoteNewestUpdatedAt: remoteMedia.fileNewestUpdatedAt,
+        newestSide: whereNewest(localMedia.fileNewestUpdatedAt, remoteMedia.fileNewestUpdatedAt),
+        localError: localMedia.error,
+        remoteError: remoteMedia.error,
+      });
+
+      rows.push({
+        uid: 'upload.morph',
+        type: 'media_morph',
+        localCount: localMedia.morphCount,
+        remoteCount: remoteMedia.morphCount,
+        localNewestUpdatedAt: localMedia.morphNewestUpdatedAt,
+        remoteNewestUpdatedAt: remoteMedia.morphNewestUpdatedAt,
+        newestSide: whereNewest(localMedia.morphNewestUpdatedAt, remoteMedia.morphNewestUpdatedAt),
+        localError: localMedia.error,
+        remoteError: remoteMedia.morphCount === null ? 'Remote morph stats are unavailable via public API' : remoteMedia.error,
+      });
+
+      return {
+        generatedAt: new Date().toISOString(),
+        contentTypes: targets,
+        rows,
+      };
+    },
+
+    async createRunReport({ runType = 'content', trigger = 'manual', contentTypes = [], beforeStats = null }) {
+      const startedAt = new Date().toISOString();
+      const baseBefore = beforeStats || await this.collectSnapshot({ contentTypes });
+      const doc = await strapi.documents(RUN_REPORT_UID).create({
+        data: {
+          runType,
+          trigger,
+          status: 'running',
+          startedAt,
+          completedAt: null,
+          contentTypes: baseBefore.contentTypes,
+          beforeStats: baseBefore,
+          afterStats: null,
+          summary: null,
+          error: null,
+        },
+      });
+      return { reportId: doc.documentId, startedAt, beforeStats: baseBefore };
+    },
+
+    async completeRunReport(reportId, { status = 'success', summary = null, error = null } = {}) {
+      if (!reportId) return null;
+      const report = await strapi.documents(RUN_REPORT_UID).findFirst({
+        filters: { documentId: reportId },
+        fields: ['documentId'],
+      });
+      if (!report?.documentId) return null;
+
+      const before = await strapi.documents(RUN_REPORT_UID).findFirst({
+        filters: { documentId: reportId },
+        fields: ['contentTypes'],
+      });
+
+      const afterStats = await this.collectSnapshot({ contentTypes: before?.contentTypes || [] });
+      await strapi.documents(RUN_REPORT_UID).update({
+        documentId: report.documentId,
+        data: {
+          status,
+          completedAt: new Date().toISOString(),
+          afterStats,
+          summary: summary || null,
+          error: error || null,
+        },
+      });
+      return { reportId: report.documentId, status };
+    },
+
+    async getLatestSnapshot() {
+      return this.collectSnapshot({});
+    },
+
+    async getReports({ page = 1, pageSize = 10 } = {}) {
+      const start = (page - 1) * pageSize;
+      const [data, total] = await Promise.all([
+        strapi.documents(RUN_REPORT_UID).findMany({
+          sort: { createdAt: 'desc' },
+          start,
+          limit: pageSize,
+        }),
+        strapi.documents(RUN_REPORT_UID).count(),
+      ]);
+
+      return {
+        data,
+        meta: {
+          pagination: {
+            page,
+            pageSize,
+            pageCount: Math.ceil(total / pageSize),
+            total,
+          },
+        },
+      };
+    },
+
+    async clearReports() {
+      const existing = await strapi.documents(RUN_REPORT_UID).findMany({
+        fields: ['documentId'],
+        sort: { createdAt: 'desc' },
+        limit: 10000,
+      });
+
+      for (const report of existing) {
+        if (!report?.documentId) continue;
+        await strapi.documents(RUN_REPORT_UID).delete({ documentId: report.documentId });
+      }
+
+      return { deleted: existing.length };
+    },
+
+    async applyRetention({ maxReports = 200 } = {}) {
+      const safeMax = Math.max(10, Number(maxReports) || 200);
+      const total = await strapi.documents(RUN_REPORT_UID).count();
+      if (total <= safeMax) return { pruned: 0, remaining: total };
+
+      const excess = total - safeMax;
+      const oldReports = await strapi.documents(RUN_REPORT_UID).findMany({
+        fields: ['documentId'],
+        sort: { createdAt: 'asc' },
+        limit: excess,
+      });
+
+      for (const report of oldReports) {
+        if (!report?.documentId) continue;
+        await strapi.documents(RUN_REPORT_UID).delete({ documentId: report.documentId });
+      }
+
+      return { pruned: oldReports.length, remaining: total - oldReports.length };
+    },
+  };
+};