@pintawebware/strapi-sync 1.0.4

package/lib/sync-engine.js

@@ -0,0 +1,379 @@
+const { mapWithConcurrency } = require('./async');
+const { contentTypeDisplayName } = require('./format');
+const {
+  getContentTypeId,
+  getEntryLocale,
+  getSchemaAttrsFromSnapshot,
+  getComparableSchemaAttrs,
+  entryDataDiff,
+  simplifyAttributeType,
+  hasSnapshotEntries,
+  stripIgnoredFields
+} = require('./snapshot-utils');
+const { buildToAddToUpdateOnlyInStrapi } = require('./preview');
+const { buildStrapiSchema, buildStrapiComponentSchema, applyLocalizationToSchema } = require('./schema-writer');
+
+async function fetchStrapiState(client, groupedObjects, concurrency = 4) {
+  const apiTypes = await client.getAllContentTypes();
+  const contentId = getContentTypeId;
+  const pluralByType = new Map(apiTypes.map((t) => [contentId(t), t.pluralName]).filter(([, p]) => p));
+  const schemaByType = new Map(apiTypes.map((t) => [contentId(t), t.schema]).filter(([, s]) => s));
+  const allTypeNames = Array.from(new Set([...Object.keys(groupedObjects), ...apiTypes.map(contentId)])).filter(Boolean);
+
+  const existingSchemas = {};
+  const existingEntriesByType = {};
+  const apiIdByType = new Map();
+
+  await mapWithConcurrency(allTypeNames, concurrency, async (contentType) => {
+    const listSchema = schemaByType.get(contentType);
+    if (listSchema) {
+      existingSchemas[contentType] = { data: { contentType: listSchema } };
+    } else {
+      try {
+        existingSchemas[contentType] = await client.getContentTypeSchema(contentType);
+      } catch (err) {
+        if (err.status === 401 || err.status === 403) throw err;
+        existingSchemas[contentType] = null;
+      }
+    }
+
+    const schema = existingSchemas[contentType];
+    const schemaData = schema?.data?.contentType ?? schema?.data?.schema ?? schema?.data;
+    const kind = schemaData?.kind ?? schema?.data?.contentType?.kind ?? schema?.data?.kind;
+    const singleType = kind === 'singleType';
+    const localized = !!(schemaData?.pluginOptions?.i18n?.localized);
+    const apiId =
+      pluralByType.get(contentType) ??
+      (schemaData?.pluralName && String(schemaData.pluralName).toLowerCase()) ??
+      schema?.data?.contentType?.pluralName ??
+      schema?.data?.schema?.pluralName ??
+      schema?.data?.apiID ??
+      schema?.apiID;
+
+    if (apiId) apiIdByType.set(contentType, apiId);
+
+    try {
+      existingEntriesByType[contentType] = await client.getEntries(contentType, {}, {
+        singleType,
+        pageSize: singleType ? undefined : 500,
+        apiId,
+        locale: 'all',
+        localized
+      });
+    } catch (err) {
+      if (err.status === 401 || err.status === 403) throw err;
+      existingEntriesByType[contentType] = [];
+    }
+  });
+
+  return {
+    apiTypes,
+    existingSchemas,
+    existingEntriesByType,
+    apiIdByType
+  };
+}
+
+function diffComponentSchemas(snapshotAttrs, strapiSimpleAttrs) {
+  const snapshotKeys = Object.keys(snapshotAttrs);
+  const strapiKeys = Object.keys(strapiSimpleAttrs);
+  return (
+    snapshotKeys.length !== strapiKeys.length ||
+    snapshotKeys.some((key) => JSON.stringify(strapiSimpleAttrs[key]) !== JSON.stringify(snapshotAttrs[key])) ||
+    strapiKeys.some((key) => JSON.stringify(snapshotAttrs[key]) !== JSON.stringify(strapiSimpleAttrs[key]))
+  );
+}
+
+async function computeComponentChanges(client, snapshotComponents, includeStrapiOnlyRemovals) {
+  const apiComponents = await client.getAllComponents();
+  const apiComponentUids = apiComponents.map((component) => component.uid);
+  const existingSet = new Set(apiComponentUids);
+  const onlyInSnapshotComponents = Object.keys(snapshotComponents).filter((uid) => !existingSet.has(uid));
+  const onlyInStrapiComponents = includeStrapiOnlyRemovals
+    ? apiComponentUids.filter((uid) => !(uid in snapshotComponents))
+    : [];
+  const componentSchemaChangesByUid = new Map();
+
+  for (const component of apiComponents) {
+    if (!(component.uid in snapshotComponents)) continue;
+    const snapshotAttrs = snapshotComponents[component.uid]?.attributes ?? {};
+    const strapiRawAttrs = component.schema?.attributes ?? {};
+    const strapiSimpleAttrs = Object.fromEntries(
+      Object.entries(strapiRawAttrs).map(([key, value]) => [key, simplifyAttributeType(value)])
+    );
+    if (diffComponentSchemas(snapshotAttrs, strapiSimpleAttrs)) {
+      componentSchemaChangesByUid.set(component.uid, { strapiSimpleAttrs, snapshotAttrs });
+    }
+  }
+
+  return {
+    onlyInStrapiComponents,
+    onlyInSnapshotComponents,
+    componentSchemaChangesByUid
+  };
+}
+
+function getPreviewCounts(groupedObjects, schemaChangesByType, contentChangesByType, onlyInStrapiContentTypes, componentChanges, schemaUpdatesEnabled) {
+  let detected = 0;
+  let actionable = 0;
+
+  for (const contentType of Object.keys(groupedObjects)) {
+    const hasContentChange = contentChangesByType.get(contentType) === true;
+    const hasSchemaChange = schemaChangesByType.get(contentType) === true;
+    if (hasContentChange || hasSchemaChange) detected += 1;
+    if (hasContentChange || (schemaUpdatesEnabled && hasSchemaChange)) actionable += 1;
+  }
+
+  detected +=
+    onlyInStrapiContentTypes.length +
+    componentChanges.onlyInStrapiComponents.length +
+    componentChanges.onlyInSnapshotComponents.length +
+    componentChanges.componentSchemaChangesByUid.size;
+
+  if (schemaUpdatesEnabled) {
+    actionable +=
+      onlyInStrapiContentTypes.length +
+      componentChanges.onlyInStrapiComponents.length +
+      componentChanges.onlyInSnapshotComponents.length +
+      componentChanges.componentSchemaChangesByUid.size;
+  }
+
+  return { detected, actionable };
+}
+
+function getNonActionableNotes(groupedObjects, schemaChangesByType, onlyInStrapiContentTypes, componentChanges, schemaUpdatesEnabled) {
+  if (schemaUpdatesEnabled) return [];
+
+  const notes = [];
+  const schemaOnlyTypes = Object.keys(groupedObjects).filter(
+    (contentType) => schemaChangesByType.get(contentType) === true
+  );
+
+  if (schemaOnlyTypes.length > 0) {
+    notes.push('Schema changes were detected but schema updates are disabled.');
+  }
+  if (onlyInStrapiContentTypes.length > 0 || componentChanges.onlyInStrapiComponents.length > 0) {
+    notes.push('Strapi-only schemas and components will not be removed while schema updates are disabled.');
+  }
+  if (componentChanges.onlyInSnapshotComponents.length > 0 || componentChanges.componentSchemaChangesByUid.size > 0) {
+    notes.push('Snapshot component changes require schema updates to be enabled.');
+  }
+
+  return notes;
+}
+
+async function applySchemaChanges(options) {
+  const {
+    schemaUpdater,
+    snapshotComponents,
+    snapshotContentTypes,
+    onlyInSnapshotComponents,
+    componentSchemaChangesByUid,
+    schemaChangesByType,
+    localizationChangesByType,
+    singleTypeChangesByType,
+    existingSchemas,
+    onlyInStrapiContentTypes,
+    onlyInStrapiComponents
+  } = options;
+
+  let schemaWasUpdated = false;
+
+  if (!schemaUpdater) return schemaWasUpdated;
+
+  console.log('📝 Updating Strapi schemas...');
+
+  for (const [componentUid, block] of Object.entries(snapshotComponents)) {
+    const isNew = onlyInSnapshotComponents.includes(componentUid);
+    const hasSchemaChange = componentSchemaChangesByUid.has(componentUid);
+    if (!isNew && !hasSchemaChange) continue;
+    schemaWasUpdated = true;
+    const schemaObj = buildStrapiComponentSchema(componentUid, block);
+    await schemaUpdater.writeComponent(componentUid, schemaObj);
+    console.log(`   ✓ component ${componentUid}`);
+  }
+
+  for (const [contentType, block] of Object.entries(snapshotContentTypes)) {
+    const schemaChanged = schemaChangesByType.get(contentType);
+    const isNewType = !existingSchemas[contentType] || existingSchemas[contentType] === null;
+    if (!schemaChanged && !isNewType) continue;
+    const locChange = localizationChangesByType.get(contentType);
+    const singleTypeChange = singleTypeChangesByType.get(contentType);
+    const locSuffix = locChange ? ` (localization: ${locChange.to ? 'enabled' : 'disabled'})` : '';
+    const localizationOnly = locChange && !singleTypeChange && !isNewType && (() => {
+      const raw = existingSchemas[contentType]?.data?.contentType?.attributes ??
+        existingSchemas[contentType]?.data?.schema?.attributes ?? {};
+      const strapiSimpleAttrs = Object.fromEntries(
+        Object.entries(raw).map(([key, value]) => [key, simplifyAttributeType(value)])
+      );
+      const snapshotAttrs = block.attributes ?? {};
+      const snapshotKeys = Object.keys(snapshotAttrs);
+      const strapiKeys = Object.keys(strapiSimpleAttrs);
+      return (
+        snapshotKeys.length === strapiKeys.length &&
+        snapshotKeys.every((key) => JSON.stringify(strapiSimpleAttrs[key]) === JSON.stringify(snapshotAttrs[key]))
+      );
+    })();
+
+    if (localizationOnly) {
+      const rawExisting = existingSchemas[contentType]?.data?.contentType ??
+        existingSchemas[contentType]?.data?.schema ??
+        existingSchemas[contentType]?.data;
+      const localizedSchema = applyLocalizationToSchema(rawExisting, locChange.to);
+      schemaWasUpdated = true;
+      await schemaUpdater.writeSchema(contentType, localizedSchema);
+      console.log(`   ✓ ${contentType}${locSuffix}`);
+      continue;
+    }
+
+    schemaWasUpdated = true;
+    let schemaObj = buildStrapiSchema(contentType, block);
+    if (!isNewType && !hasSnapshotEntries(block)) {
+      const currentLocalized = !!(
+        existingSchemas[contentType]?.data?.contentType?.pluginOptions?.i18n?.localized ??
+        existingSchemas[contentType]?.data?.schema?.pluginOptions?.i18n?.localized ??
+        existingSchemas[contentType]?.data?.pluginOptions?.i18n?.localized
+      );
+      schemaObj = applyLocalizationToSchema(schemaObj, currentLocalized);
+    }
+    await schemaUpdater.writeSchema(contentType, schemaObj);
+    await schemaUpdater.writeCoreFiles(contentType);
+    console.log(`   ✓ ${contentType}${locSuffix}`);
+  }
+
+  for (const contentType of onlyInStrapiContentTypes) {
+    schemaWasUpdated = true;
+    await schemaUpdater.deleteContentType(contentType);
+    console.log(`   🗑 ${contentType}`);
+  }
+
+  for (const componentUid of onlyInStrapiComponents) {
+    schemaWasUpdated = true;
+    await schemaUpdater.deleteComponent(componentUid);
+    console.log(`   🗑 component ${componentUid}`);
+  }
+
+  return schemaWasUpdated;
+}
+
+async function waitForStrapiReload(client, options = {}) {
+  const interval = options.reloadPollInterval ?? 1500;
+  const timeoutMs = options.reloadTimeoutMs ?? 60000;
+
+  console.log('  ⏳ Pausing 3s for Strapi to start reloading...');
+  await new Promise((resolve) => setTimeout(resolve, 3000));
+
+  const frames = ['⏳', '⌛'];
+  let frameIndex = 0;
+  const animation = setInterval(() => {
+    const line = `  ${frames[frameIndex % frames.length]} Waiting for Strapi to reload...`;
+    process.stdout.write('\r\x1b[K' + line);
+    frameIndex += 1;
+  }, 400);
+
+  const deadline = Date.now() + timeoutMs;
+  let ready = false;
+  while (Date.now() < deadline) {
+    if (await client.ping()) {
+      ready = true;
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+
+  clearInterval(animation);
+  process.stdout.write('\r\x1b[K');
+
+  if (ready) {
+    console.log('   ✓ Strapi is ready');
+    return true;
+  }
+
+  console.warn(`   ⚠️  Strapi did not respond within ${timeoutMs / 1000}s. Content sync skipped.`);
+  return false;
+}
+
+async function applyContentChanges(client, groupedObjects, snapshotContentTypes, existingSchemas, existingEntriesByType, apiIdByType, contentChangesByType, schemaChangesByType = new Map()) {
+  let changesApplied = false;
+
+  const sortedTypes = Object.keys(groupedObjects).sort((left, right) => {
+    const leftSchema = schemaChangesByType.get(left) ? 1 : 0;
+    const rightSchema = schemaChangesByType.get(right) ? 1 : 0;
+    return rightSchema - leftSchema;
+  });
+
+  for (const contentType of sortedTypes) {
+    if (!contentChangesByType.get(contentType)) continue;
+
+    const typeObjects = groupedObjects[contentType];
+    const singleType = typeObjects.some((entry) => entry.singleType);
+    const existingEntries = existingEntriesByType[contentType] || [];
+    const apiId =
+      apiIdByType.get(contentType) ??
+      existingSchemas[contentType]?.data?.contentType?.pluralName ??
+      existingSchemas[contentType]?.data?.apiID;
+    const snapshotAttrs = getSchemaAttrsFromSnapshot(snapshotContentTypes, contentType);
+    const comparableAttrs =
+      Object.keys(snapshotAttrs).length > 0
+        ? getComparableSchemaAttrs(snapshotAttrs)
+        : {};
+    const { toAdd, toUpdate, onlyInStrapi } = buildToAddToUpdateOnlyInStrapi(
+      contentType,
+      typeObjects,
+      existingEntries,
+      snapshotContentTypes,
+      singleType
+    );
+
+    if (onlyInStrapi.length > 0) {
+      for (const entry of onlyInStrapi) {
+        const deleteId = entry.documentId ?? entry.id;
+        console.log(`   🗑 Deleting: ${deleteId}${getEntryLocale(entry) ? ` [${getEntryLocale(entry)}]` : ''}`);
+        await client.deleteEntry(contentType, deleteId, { apiId, locale: getEntryLocale(entry) || undefined });
+      }
+      changesApplied = true;
+      console.log(`✓ Deleted ${onlyInStrapi.length} entr${onlyInStrapi.length === 1 ? 'y' : 'ies'}`);
+    }
+
+    const updates = [...toAdd.map((item) => ({ ...item, isCreate: true })), ...toUpdate.map((item) => ({ ...item, isCreate: false }))];
+    if (updates.length === 0) continue;
+
+    console.log(`📋 ${contentTypeDisplayName(contentType)}`);
+    console.log('💾 Updating content in Strapi...');
+
+    const skippedFields = Object.keys(snapshotAttrs).filter((key) => !(key in comparableAttrs));
+    if (skippedFields.length > 0) {
+      console.log(`   ⚠️  Skipping unsupported fields: ${skippedFields.join(', ')}`);
+    }
+
+    for (const entry of updates) {
+      const locale = entry.itemLocale ?? entry.locale ?? '';
+      const sourceData = entry.isCreate ? entry.data : entryDataDiff(entry.data, entry.existing, comparableAttrs);
+      const payload = stripIgnoredFields(sourceData, snapshotAttrs);
+      if (!entry.isCreate && (!payload || Object.keys(payload).filter((key) => key !== 'id' && key !== 'documentId').length === 0)) {
+        continue;
+      }
+      if (entry.isCreate && !singleType) {
+        await client.createEntry(contentType, payload, { singleType, apiId, locale });
+        continue;
+      }
+      const targetId = singleType ? null : (entry.existing?.documentId ?? entry.existing?.id ?? entry.data.documentId ?? entry.data.id);
+      await client.updateEntry(contentType, targetId, payload, { singleType, apiId, locale });
+    }
+
+    changesApplied = true;
+    console.log(`✓ Applied ${updates.length} entr${updates.length === 1 ? 'y' : 'ies'}`);
+  }
+
+  return changesApplied;
+}
+
+module.exports = {
+  fetchStrapiState,
+  computeComponentChanges,
+  getPreviewCounts,
+  getNonActionableNotes,
+  applySchemaChanges,
+  waitForStrapiReload,
+  applyContentChanges
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@pintawebware/strapi-sync",
+  "version": "1.0.4",
+  "description": "Export Strapi content to snapshot JSON and apply snapshot content to Strapi",
+  "main": "index.js",
+  "bin": {
+    "strapi-sync": "bin/cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "strapi",
+    "sync",
+    "cli",
+    "cms",
+    "frontend"
+  ],
+  "author": "",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "dotenv": "^17.3.1",
+    "ssh2": "^1.15.0"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "index.js"
+  ]
+}