@pintawebware/strapi-sync 1.0.4

package/lib/config.js

@@ -0,0 +1,183 @@
+const path = require('path');
+const fs = require('fs');
+const dotenv = require('dotenv');
+const { CONFIG_FILES, DEFAULT_OUTPUT } = require('./constants');
+
+function loadConfigFile(configPath) {
+  if (!fs.existsSync(configPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch (error) {
+    console.warn(`⚠️  Failed to load config file ${configPath}: ${error.message}`);
+    return null;
+  }
+}
+
+function findConfigFile(projectPath) {
+  for (const name of CONFIG_FILES) {
+    const configPath = path.join(projectPath, name);
+    if (fs.existsSync(configPath)) return configPath;
+  }
+  return null;
+}
+
+function loadConfig(projectPath) {
+  const configPath = findConfigFile(projectPath);
+  if (!configPath) return null;
+  console.log(`📄 Loading config from: ${configPath}`);
+  return loadConfigFile(configPath);
+}
+
+function loadEnv(projectPath) {
+  dotenv.config({ path: path.join(projectPath, '.env') });
+}
+
+const FLAGS = {
+  project: ['--project', '-p'],
+  strapiUrl: ['--strapi-url', '-u'],
+  apiToken: ['--api-token'],
+  export: ['--export'],
+  output: ['--output'],
+  strapiProjectPath: ['--strapi-project'],
+  strapiSSHHost: ['--strapi-ssh-host'],
+  strapiSSHUser: ['--strapi-ssh-user'],
+  strapiSSHPort: ['--strapi-ssh-port'],
+  strapiSSHPassword: ['--strapi-ssh-password'],
+  strapiSSHPrivateKeyPath: ['--strapi-ssh-key'],
+  config: ['--config'],
+  help: ['--help', '-h'],
+  version: ['--version', '-v']
+};
+
+const ENV_BY_OPTION = {
+  strapiUrl: 'STRAPI_URL',
+  apiToken: 'STRAPI_API_TOKEN',
+  strapiProjectPath: 'STRAPI_PROJECT_PATH',
+  strapiSSHHost: 'STRAPI_SSH_HOST',
+  strapiSSHUser: 'STRAPI_SSH_USER',
+  strapiSSHPort: 'STRAPI_SSH_PORT',
+  strapiSSHPassword: 'STRAPI_SSH_PASSWORD',
+  strapiSSHPrivateKeyPath: 'STRAPI_SSH_PRIVATE_KEY_PATH'
+};
+
+function matchesFlag(flagSet, value) {
+  return flagSet.includes(value);
+}
+
+function parseNumber(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function isMissing(value) {
+  return value == null || value === '';
+}
+
+function applyEnvFallbacks(options) {
+  for (const [optionKey, envKey] of Object.entries(ENV_BY_OPTION)) {
+    if (!isMissing(options[optionKey])) continue;
+    const envValue = process.env[envKey];
+    if (isMissing(envValue)) continue;
+    options[optionKey] = optionKey === 'strapiSSHPort'
+      ? parseNumber(envValue, undefined)
+      : envValue;
+  }
+}
+
+function requireFlagValue(args, index, flag) {
+  const value = args[index + 1];
+  if (value == null || value.startsWith('-')) {
+    throw new Error(`Unknown or incomplete CLI arguments: expected value after ${flag}`);
+  }
+  return value;
+}
+
+function parseCliArgs(args) {
+  const cliOptions = {};
+  let customConfigPath = null;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (matchesFlag(FLAGS.help, arg)) {
+      cliOptions.help = true;
+      continue;
+    }
+    if (matchesFlag(FLAGS.version, arg)) {
+      cliOptions.version = true;
+      continue;
+    }
+    if (matchesFlag(FLAGS.project, arg)) cliOptions.projectPath = requireFlagValue(args, i++, arg);
+    else if (matchesFlag(FLAGS.strapiUrl, arg)) cliOptions.strapiUrl = requireFlagValue(args, i++, arg);
+    else if (matchesFlag(FLAGS.apiToken, arg)) cliOptions.apiToken = requireFlagValue(args, i++, arg);
+    else if (matchesFlag(FLAGS.export, arg)) cliOptions.mode = 'export';
+    else if (matchesFlag(FLAGS.output, arg)) cliOptions.output = requireFlagValue(args, i++, arg);
+    else if (matchesFlag(FLAGS.strapiProjectPath, arg)) cliOptions.strapiProjectPath = requireFlagValue(args, i++, arg);
+    else if (matchesFlag(FLAGS.strapiSSHHost, arg)) cliOptions.strapiSSHHost = requireFlagValue(args, i++, arg);
+    else if (matchesFlag(FLAGS.strapiSSHUser, arg)) cliOptions.strapiSSHUser = requireFlagValue(args, i++, arg);
+    else if (matchesFlag(FLAGS.strapiSSHPort, arg)) cliOptions.strapiSSHPort = parseNumber(requireFlagValue(args, i++, arg), undefined);
+    else if (matchesFlag(FLAGS.strapiSSHPassword, arg)) cliOptions.strapiSSHPassword = requireFlagValue(args, i++, arg);
+    else if (matchesFlag(FLAGS.strapiSSHPrivateKeyPath, arg)) cliOptions.strapiSSHPrivateKeyPath = requireFlagValue(args, i++, arg);
+    else if (matchesFlag(FLAGS.config, arg)) customConfigPath = requireFlagValue(args, i++, arg);
+    else if (arg.startsWith('-')) throw new Error(`Unknown CLI argument: ${arg}`);
+  }
+
+  return { cliOptions, customConfigPath };
+}
+
+function finalizeMode(options) {
+  const mode = options.mode || 'apply';
+  return {
+    ...options,
+    mode,
+    export: mode === 'export'
+  };
+}
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const cwd = process.cwd();
+  const { cliOptions, customConfigPath } = parseCliArgs(args);
+
+  if (cliOptions.help) return { help: true };
+  if (cliOptions.version) return { version: true };
+
+  const projectPath = path.resolve(cliOptions.projectPath || cwd);
+  loadEnv(projectPath);
+  const options = {
+    projectPath,
+    strapiUrl: null,
+    apiToken: null,
+    output: DEFAULT_OUTPUT,
+    updateSchema: true,
+    strapiProjectPath: null,
+    reloadPollInterval: 1500,
+    reloadTimeoutMs: 60000,
+    strapiSSHHost: null,
+    strapiSSHUser: null,
+    strapiSSHPort: null,
+    strapiSSHPassword: null,
+    strapiSSHPrivateKeyPath: null,
+    mode: 'apply'
+  };
+
+  const discoveredConfig = loadConfig(projectPath);
+  if (discoveredConfig) Object.assign(options, discoveredConfig);
+
+  if (customConfigPath) {
+    const customConfig = loadConfigFile(path.resolve(customConfigPath));
+    if (customConfig) Object.assign(options, customConfig);
+  }
+
+  Object.assign(options, cliOptions);
+  applyEnvFallbacks(options);
+  options.projectPath = projectPath;
+
+  return finalizeMode(options);
+}
+
+module.exports = {
+  loadConfig,
+  loadConfigFile,
+  findConfigFile,
+  parseArgs
+};

package/lib/constants.js

@@ -0,0 +1,20 @@
+const SNAPSHOT_VERSION = 2;
+
+const COLORS = {
+  RED: '\x1b[31m',
+  GREEN: '\x1b[32m',
+  YELLOW: '\x1b[33m',
+  RESET: '\x1b[0m'
+};
+
+const CONFIG_FILES = ['.strapi-sync.json', 'strapi-sync.config.json', 'strapi-sync.json'];
+const DEFAULT_OUTPUT = 'strapi-snapshot.json';
+const MAX_LOG_STRING = 120;
+
+module.exports = {
+  SNAPSHOT_VERSION,
+  COLORS,
+  CONFIG_FILES,
+  DEFAULT_OUTPUT,
+  MAX_LOG_STRING
+};

package/lib/format.js

@@ -0,0 +1,46 @@
+const { COLORS, MAX_LOG_STRING } = require('./constants');
+
+function isMediaField(key) {
+  const name = (key || '').toLowerCase();
+  return name.endsWith('media') || name.endsWith('files');
+}
+
+function contentTypeDisplayName(s) {
+  if (!s || typeof s !== 'string') return s;
+  return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
+}
+
+function formatContentForLog(data, indent = '       ') {
+  if (data === null || data === undefined) return '';
+  if (typeof data !== 'object') return String(data);
+  const lines = [];
+  for (const [key, value] of Object.entries(data)) {
+    if (isMediaField(key)) continue;
+    if (Array.isArray(value)) {
+      lines.push(`${indent}${key}: [${value.length} item(s)]`);
+      value.slice(0, 3).forEach((item, i) => {
+        if (item && typeof item === 'object') {
+          const str = JSON.stringify(item);
+          lines.push(`${indent}  [${i}]: ${str.slice(0, MAX_LOG_STRING)}${str.length > MAX_LOG_STRING ? '…' : ''}`);
+        } else {
+          lines.push(`${indent}  [${i}]: ${String(item).slice(0, MAX_LOG_STRING)}`);
+        }
+      });
+      if (value.length > 3) lines.push(`${indent}  ... and ${value.length - 3} more`);
+    } else if (value !== null && typeof value === 'object') {
+      lines.push(`${indent}${key}:`);
+      lines.push(formatContentForLog(value, indent + '  '));
+    } else {
+      const str = String(value);
+      lines.push(`${indent}${key}: ${str.length > MAX_LOG_STRING ? str.slice(0, MAX_LOG_STRING) + '…' : str}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+module.exports = {
+  COLORS,
+  isMediaField,
+  contentTypeDisplayName,
+  formatContentForLog
+};

package/lib/preview.js

@@ -0,0 +1,373 @@
+const { COLORS } = require('./format');
+const {
+  simplifyAttributeType,
+  entryDataDiffers,
+  entryDataDiff,
+  getEntryLocale,
+  getSchemaAttrsFromSnapshot,
+  getComparableSchemaAttrs,
+  isLocalizedSnapshotBlock,
+  hasSnapshotEntries
+} = require('./snapshot-utils');
+
+function collectItemsToShow(typeObjects) {
+  const forContent = typeObjects.filter((o) => o.source !== 'schema-only');
+  const items = [];
+  for (const obj of forContent) {
+    const loc = obj.locale;
+    if (Array.isArray(obj.data)) {
+      for (const item of obj.data) {
+        if (item && typeof item === 'object') items.push({ data: item, locale: loc });
+      }
+    } else if (obj.data && typeof obj.data === 'object') {
+      items.push({ data: obj.data, locale: loc });
+    }
+  }
+  return items;
+}
+
+function findExistingEntry(item, existingEntries, singleType, entryLoc) {
+  const { data, locale } = item;
+  if (!data) return [];
+  let existing = existingEntries.filter((e) => {
+    if (data.id == null || e.id == null) return false;
+    const matchId = String(data.id) === String(e.id);
+    if (locale != null && locale !== '') return matchId && entryLoc(e) === locale;
+    return matchId;
+  });
+  if (singleType && existing.length === 0 && existingEntries.length > 0 && (!locale || locale === '')) {
+    existing = existingEntries.length > 0 ? [existingEntries[0]] : existing;
+  }
+  return existing;
+}
+
+function buildToAddToUpdateOnlyInStrapi(contentType, typeObjects, existingEntries, snapshotContentTypes, singleType) {
+  const itemsToShow = collectItemsToShow(typeObjects);
+  const snapshotAttrs = getSchemaAttrsFromSnapshot(snapshotContentTypes, contentType);
+  const schemaKeysForCompare =
+    Object.keys(snapshotAttrs).length > 0
+      ? getComparableSchemaAttrs(snapshotAttrs)
+      : Object.keys(typeObjects[0]?.data || {}).filter((k) => k !== 'id');
+
+  const toAdd = [];
+  const toUpdate = [];
+  const matchedExistingIds = new Set();
+
+  for (const item of itemsToShow) {
+    const { data } = item;
+    if (!data) continue;
+    const existing = findExistingEntry(item, existingEntries, singleType, getEntryLocale);
+    const isCreate = existing.length === 0 && !singleType;
+    const needsUpdate = existing.length > 0 && entryDataDiffers(data, existing[0], schemaKeysForCompare);
+    const singleTypeApply = singleType && existing.length === 0;
+
+    if (existing.length > 0 && existing[0].id != null) {
+      matchedExistingIds.add(`${existing[0].id}_${getEntryLocale(existing[0])}`);
+    }
+    if (isCreate) toAdd.push({ data, itemLocale: item.locale });
+    else if (needsUpdate) toUpdate.push({ data, itemLocale: item.locale, existing: existing[0] });
+    else if (singleTypeApply) toUpdate.push({ data, itemLocale: item.locale, existing: {} });
+  }
+
+  const onlyInStrapi = !singleType
+    ? existingEntries.filter((e) => e.id == null || !matchedExistingIds.has(`${e.id}_${getEntryLocale(e)}`))
+    : [];
+
+  return { toAdd, toUpdate, onlyInStrapi, schemaKeysForCompare };
+}
+
+function attrEqual(a, b) {
+  if (Array.isArray(a) && Array.isArray(b)) return JSON.stringify(a) === JSON.stringify(b);
+  if (Array.isArray(a) || Array.isArray(b)) return false;
+  return a === b;
+}
+
+function attrDisplay(v) {
+  if (Array.isArray(v)) return `[${v.join(', ')}]`;
+  return v;
+}
+
+function schemaDiffers(snapshotAttrs, strapiSimpleAttrs) {
+  const snapKeys = Object.keys(snapshotAttrs);
+  const strapiKeys = Object.keys(strapiSimpleAttrs);
+  return (
+    snapKeys.length !== strapiKeys.length ||
+    snapKeys.some((k) => !attrEqual(strapiSimpleAttrs[k], snapshotAttrs[k])) ||
+    strapiKeys.some((k) => !attrEqual(snapshotAttrs[k], strapiSimpleAttrs[k]))
+  );
+}
+
+function getStrapiSimpleAttrs(schema) {
+  const raw = schema?.data?.contentType?.attributes ?? schema?.data?.schema?.attributes ?? {};
+  return Object.fromEntries(Object.entries(raw).map(([k, v]) => [k, simplifyAttributeType(v)]));
+}
+
+function getStrapiLocalization(schema) {
+  const ct = schema?.data?.contentType ?? schema?.data?.schema ?? schema?.data;
+  return !!(ct?.pluginOptions?.i18n?.localized);
+}
+
+function getStrapiSingleType(schema) {
+  const ct = schema?.data?.contentType ?? schema?.data?.schema ?? schema?.data;
+  return ct?.kind === 'singleType';
+}
+
+function computeChangeMaps(groupedObjects, snapshotContentTypes, existingSchemas, existingEntriesByType, getContentTypeId) {
+  const schemaChangesByType = new Map();
+  const contentChangesByType = new Map();
+  const localizationChangesByType = new Map();
+  const singleTypeChangesByType = new Map();
+  let previewCount = 0;
+
+  for (const [contentType, typeObjects] of Object.entries(groupedObjects)) {
+    const singleType = typeObjects.some((o) => o.singleType);
+    const existingEntries = existingEntriesByType[contentType] || [];
+    const itemsToShow = collectItemsToShow(typeObjects);
+    const snapshotAttrsForCompare = getSchemaAttrsFromSnapshot(snapshotContentTypes, contentType);
+    const schemaKeysForCompare =
+      Object.keys(snapshotAttrsForCompare).length > 0
+        ? getComparableSchemaAttrs(snapshotAttrsForCompare)
+        : Object.keys(typeObjects[0]?.data || {}).filter((k) => k !== 'id');
+
+    let needSyncCount = 0;
+    let onlyInStrapiCount = 0;
+    if (!singleType && existingEntries.length > 0 && itemsToShow.length > 0) {
+      const matchedKeys = new Set(
+        itemsToShow.filter((i) => i.data?.id != null).map((i) => `${String(i.data.id)}_${i.locale || ''}`)
+      );
+      onlyInStrapiCount = existingEntries.filter(
+        (e) => e.id == null || !matchedKeys.has(`${String(e.id)}_${getEntryLocale(e)}`)
+      ).length;
+    }
+    for (const item of itemsToShow) {
+      const existing = findExistingEntry(item, existingEntries, singleType, getEntryLocale);
+      if (existing.length === 0) needSyncCount++;
+      else if (entryDataDiffers(item.data, existing[0], schemaKeysForCompare)) needSyncCount++;
+    }
+    const hasContentToShow = needSyncCount > 0 || onlyInStrapiCount > 0;
+    contentChangesByType.set(contentType, hasContentToShow);
+
+    const schema = existingSchemas[contentType];
+    const strapiSimpleAttrs = getStrapiSimpleAttrs(schema);
+    const snapshotAttrs = snapshotContentTypes[contentType]?.attributes ?? {};
+    const strapiLocalized = getStrapiLocalization(schema);
+    const snapshotBlock = snapshotContentTypes[contentType];
+    const snapshotLocalized = isLocalizedSnapshotBlock(snapshotBlock);
+    const strapiSingleType = getStrapiSingleType(schema);
+    const snapshotSingleType = !!snapshotBlock?.singleType;
+    const localizationDiff = schema != null && hasSnapshotEntries(snapshotBlock) && strapiLocalized !== snapshotLocalized;
+    if (localizationDiff) localizationChangesByType.set(contentType, { from: strapiLocalized, to: snapshotLocalized });
+    const singleTypeDiff = schema != null && strapiSingleType !== snapshotSingleType;
+    if (singleTypeDiff) singleTypeChangesByType.set(contentType, { from: strapiSingleType, to: snapshotSingleType });
+    const schemaDiff = schemaDiffers(snapshotAttrs, strapiSimpleAttrs) || localizationDiff || singleTypeDiff;
+    schemaChangesByType.set(contentType, schemaDiff);
+
+    if (hasContentToShow || schemaDiff) previewCount++;
+  }
+
+  return { schemaChangesByType, contentChangesByType, localizationChangesByType, singleTypeChangesByType, previewCount };
+}
+
+function printSchemaDiff(contentType, existingSchemas, snapshotContentTypes, contentTypeDisplayName, localizationChange, singleTypeChange) {
+  const schema = existingSchemas[contentType];
+  const strapiSimpleAttrs = getStrapiSimpleAttrs(schema);
+  const snapshotAttrs = snapshotContentTypes[contentType]?.attributes ?? {};
+  const strapiHasType = schema != null && Object.keys(strapiSimpleAttrs).length > 0;
+
+  if (!strapiHasType) {
+    const attrLines = Object.entries(snapshotAttrs).map(
+      ([k, v], i, arr) => `     ${k}: ${attrDisplay(v)}${i < arr.length - 1 ? ',' : ''}`
+    );
+    console.log(`${COLORS.GREEN}${attrLines.join('\n')}${COLORS.RESET}`);
+  } else {
+    const added = Object.keys(snapshotAttrs).filter((k) => !(k in strapiSimpleAttrs));
+    const removed = Object.keys(strapiSimpleAttrs).filter((k) => !(k in snapshotAttrs));
+    const typeChanged = Object.keys(snapshotAttrs).filter(
+      (k) => strapiSimpleAttrs[k] !== undefined && !attrEqual(strapiSimpleAttrs[k], snapshotAttrs[k])
+    );
+    const parts = [
+      ...(singleTypeChange
+        ? [{
+            line: `     ~ kind: ${singleTypeChange.from ? 'singleType' : 'collectionType'} → ${singleTypeChange.to ? 'singleType' : 'collectionType'}`,
+            color: COLORS.YELLOW
+          }]
+        : []),
+      ...(localizationChange
+        ? [{
+            line: `     ~ localization: ${localizationChange.from ? 'enabled' : 'disabled'} → ${localizationChange.to ? 'enabled' : 'disabled'}`,
+            color: COLORS.YELLOW
+          }]
+        : []),
+      ...added.map((k) => ({ line: `     + ${k}: ${attrDisplay(snapshotAttrs[k])}`, color: COLORS.GREEN })),
+      ...removed.map((k) => ({ line: `     − ${k}`, color: COLORS.RED })),
+      ...typeChanged.map((k) => ({
+        line: `     ~ ${k}: ${attrDisplay(strapiSimpleAttrs[k])} → ${attrDisplay(snapshotAttrs[k])}`,
+        color: COLORS.YELLOW
+      }))
+    ];
+    parts.forEach((p, i) => {
+      console.log(`${p.color}${p.line}${i < parts.length - 1 ? ',' : ''}${COLORS.RESET}`);
+    });
+  }
+}
+
+function printPreview(
+  groupedObjects,
+  snapshotContentTypes,
+  existingSchemas,
+  existingEntriesByType,
+  onlyInStrapiContentTypes,
+  schemaChangesByType,
+  contentChangesByType,
+  contentTypeDisplayName,
+  formatContentForLog,
+  onlyInStrapiComponents = [],
+  onlyInSnapshotComponents = [],
+  componentSchemaChangesByUid = new Map(),
+  localizationChangesByType = new Map(),
+  singleTypeChangesByType = new Map()
+) {
+  console.log('\n═══════════════════════════════════════════════════════════');
+  console.log('  PREVIEW: Content and schema changes');
+  console.log('═══════════════════════════════════════════════════════════\n');
+
+  const strapiSystemKeys = new Set([
+    'id',
+    'documentId',
+    'createdAt',
+    'updatedAt',
+    'publishedAt',
+    'locale',
+    'localizations',
+    'createdBy',
+    'updatedBy'
+  ]);
+
+  const sortedContentTypes = Object.keys(groupedObjects).sort((a, b) => {
+    const aSchema = schemaChangesByType.get(a) ? 1 : 0;
+    const bSchema = schemaChangesByType.get(b) ? 1 : 0;
+    return bSchema - aSchema;
+  });
+
+  for (const contentType of sortedContentTypes) {
+    const typeObjects = groupedObjects[contentType];
+    const singleType = typeObjects.some((o) => o.singleType);
+    const existingEntries = existingEntriesByType[contentType] || [];
+    if (!contentChangesByType.get(contentType) && !schemaChangesByType.get(contentType)) continue;
+
+    const { toAdd, toUpdate, onlyInStrapi, schemaKeysForCompare } = buildToAddToUpdateOnlyInStrapi(
+      contentType,
+      typeObjects,
+      existingEntries,
+      snapshotContentTypes,
+      singleType
+    );
+    const hasSchemaChange = schemaChangesByType.get(contentType);
+    if (toAdd.length === 0 && toUpdate.length === 0 && onlyInStrapi.length === 0 && !hasSchemaChange) continue;
+
+    const schemaForNew = existingSchemas[contentType];
+    const rawForNew =
+      schemaForNew?.data?.contentType?.attributes ?? schemaForNew?.data?.schema?.attributes ?? {};
+    const isNewSchema = hasSchemaChange && (schemaForNew == null || Object.keys(rawForNew).length === 0);
+    const isUpdatedSchema = hasSchemaChange && schemaForNew != null && Object.keys(rawForNew).length > 0;
+
+    if (isNewSchema) console.log(`${COLORS.GREEN}📋 ${contentTypeDisplayName(contentType)} (new)${COLORS.RESET}`);
+    else if (isUpdatedSchema)
+      console.log(`${COLORS.YELLOW}📋 ${contentTypeDisplayName(contentType)} (edited)${COLORS.RESET}`);
+    else console.log(`📋 ${contentTypeDisplayName(contentType)}`);
+
+    if (hasSchemaChange) {
+      console.log(`   Schema:`);
+      printSchemaDiff(
+        contentType,
+        existingSchemas,
+        snapshotContentTypes,
+        contentTypeDisplayName,
+        localizationChangesByType.get(contentType),
+        singleTypeChangesByType.get(contentType)
+      );
+    }
+
+    const contentColor = isNewSchema ? COLORS.GREEN : COLORS.YELLOW;
+    const summary = [
+      toAdd.length && `${toAdd.length} to add`,
+      toUpdate.length && `${toUpdate.length} to update`,
+      onlyInStrapi.length > 0 && `${onlyInStrapi.length} to delete`
+    ]
+      .filter(Boolean)
+      .join(', ');
+    if (summary) console.log(`   Content: ${summary}`);
+
+    toAdd.forEach(({ data, itemLocale }, i) => {
+      const localeSuffix = itemLocale ? ` [${itemLocale}]` : '';
+      console.log(`     ${COLORS.GREEN}+ Entry ${i + 1}${localeSuffix}${COLORS.RESET}`);
+      console.log(`${COLORS.GREEN}${formatContentForLog(data, '         ')}${COLORS.RESET}`);
+    });
+    toUpdate.forEach(({ data, itemLocale, existing }) => {
+      const localeSuffix = itemLocale ? ` [${itemLocale}]` : '';
+      console.log(`     ${contentColor}~ Update:${data.id ? ` ${data.id}` : ''}${localeSuffix}${COLORS.RESET}`);
+      const diff = entryDataDiff(data, existing, schemaKeysForCompare);
+      console.log(`${contentColor}${formatContentForLog(diff, '         ')}${COLORS.RESET}`);
+    });
+
+    const contentAttrKeys = Object.keys(snapshotContentTypes[contentType]?.attributes || {});
+    onlyInStrapi.forEach((e, i) => {
+      const localeSuffix = getEntryLocale(e) ? ` [${getEntryLocale(e)}]` : '';
+      console.log(`     ${COLORS.RED}− Entry ${i + 1}: ${localeSuffix}${COLORS.RESET}`);
+      const raw = e.attributes ? { ...e.attributes } : { ...e };
+      const displayData =
+        contentAttrKeys.length > 0
+          ? Object.fromEntries(contentAttrKeys.filter((k) => raw[k] !== undefined).map((k) => [k, raw[k]]))
+          : Object.fromEntries(Object.entries(raw).filter(([k]) => !strapiSystemKeys.has(k)));
+      console.log(`${COLORS.RED}${formatContentForLog(displayData, '         ')}${COLORS.RESET}`);
+    });
+    console.log('');
+  }
+
+  for (const contentType of onlyInStrapiContentTypes) {
+    const schema = existingSchemas[contentType];
+    const strapiSimpleAttrs = getStrapiSimpleAttrs(schema);
+    console.log(`${COLORS.RED}📋 ${contentTypeDisplayName(contentType)} (removed)${COLORS.RESET}`);
+    console.log(`   Schema:`);
+    if (Object.keys(strapiSimpleAttrs).length > 0) {
+      const attrLines = Object.entries(strapiSimpleAttrs).map(
+        ([k, v], i, arr) => `     ${k}: ${v}${i < arr.length - 1 ? ',' : ''}`
+      );
+      console.log(`${COLORS.RED}${attrLines.join('\n')}${COLORS.RESET}`);
+    }
+    console.log('');
+  }
+  for (const componentUid of onlyInSnapshotComponents) {
+    console.log(`${COLORS.GREEN}🧩 component ${componentUid} (new)${COLORS.RESET}`);
+  }
+  for (const componentUid of onlyInStrapiComponents) {
+    console.log(`${COLORS.RED}🧩 component ${componentUid} (removed)${COLORS.RESET}`);
+  }
+  for (const [componentUid, { strapiSimpleAttrs, snapshotAttrs }] of componentSchemaChangesByUid) {
+    console.log(`${COLORS.YELLOW}🧩 component ${componentUid} (edited)${COLORS.RESET}`);
+    const added = Object.keys(snapshotAttrs).filter((k) => !(k in strapiSimpleAttrs));
+    const removed = Object.keys(strapiSimpleAttrs).filter((k) => !(k in snapshotAttrs));
+    const typeChanged = Object.keys(snapshotAttrs).filter(
+      (k) => strapiSimpleAttrs[k] !== undefined && JSON.stringify(strapiSimpleAttrs[k]) !== JSON.stringify(snapshotAttrs[k])
+    );
+    const parts = [
+      ...added.map((k) => ({ line: `     + ${k}: ${attrDisplay(snapshotAttrs[k])}`, color: COLORS.GREEN })),
+      ...removed.map((k) => ({ line: `     − ${k}`, color: COLORS.RED })),
+      ...typeChanged.map((k) => ({
+        line: `     ~ ${k}: ${attrDisplay(strapiSimpleAttrs[k])} → ${attrDisplay(snapshotAttrs[k])}`,
+        color: COLORS.YELLOW
+      }))
+    ];
+    parts.forEach((p) => console.log(`${p.color}${p.line}${COLORS.RESET}`));
+  }
+  console.log('\n═══════════════════════════════════════════════════════════\n');
+}
+
+module.exports = {
+  collectItemsToShow,
+  findExistingEntry,
+  buildToAddToUpdateOnlyInStrapi,
+  computeChangeMaps,
+  printPreview,
+  getStrapiSimpleAttrs
+};