@pintawebware/strapi-sync 1.0.4

package/lib/snapshot-utils.js

@@ -0,0 +1,392 @@
+function simplifyAttributeType(def) {
+  if (!def || typeof def !== 'object') return 'json';
+  const t = def.type;
+  const multi = def.multiple === true;
+  if (['string', 'text', 'richtext', 'uid'].includes(t)) return 'string';
+  if (['number', 'integer', 'float', 'decimal'].includes(t)) return 'number';
+  if (t === 'boolean') return 'boolean';
+  if (['date', 'datetime', 'time'].includes(t)) return 'date';
+  if (t === 'media') return multi ? 'media[]' : 'media';
+  if (t === 'component') {
+    const uid = def.component || '';
+    const repeatable = def.repeatable === true;
+    return uid ? `component:${uid}${repeatable ? ':repeatable' : ''}` : 'json';
+  }
+  if (t === 'relation') {
+    const relType = def.relation || 'oneToMany';
+    const target = compactRelationTarget(def.target || '');
+    return target ? `relation:${target}:${relType}` : 'json';
+  }
+  if (t === 'dynamiczone') {
+    return Array.isArray(def.components) ? [...def.components] : [];
+  }
+  return 'json';
+}
+
+function parseComponentType(simpleType) {
+  if (typeof simpleType !== 'string' || !simpleType.startsWith('component:')) return null;
+  const rest = simpleType.slice('component:'.length);
+  const repeatable = rest.endsWith(':repeatable');
+  const uid = repeatable ? rest.slice(0, -':repeatable'.length) : rest;
+  return uid ? { uid, repeatable } : null;
+}
+
+function parseDynamicZoneType(simpleType) {
+  if (Array.isArray(simpleType)) return { components: simpleType };
+  return null;
+}
+
+function parseRelationType(simpleType) {
+  if (typeof simpleType !== 'string' || !simpleType.startsWith('relation:')) return null;
+  const rest = simpleType.slice('relation:'.length);
+  const lastColon = rest.lastIndexOf(':');
+  if (lastColon === -1) return null;
+  const target = rest.slice(0, lastColon);
+  const relType = rest.slice(lastColon + 1);
+  return target ? { target, relType } : null;
+}
+
+function compactRelationTarget(target) {
+  if (typeof target !== 'string' || !target) return target;
+  const match = target.match(/^api::([a-z0-9-]+)\.\1$/i);
+  return match ? match[1] : target;
+}
+
+function expandRelationTarget(target) {
+  if (typeof target !== 'string' || !target) return target;
+  if (target.includes('::') || target.includes('.')) return target;
+  return `api::${target}.${target}`;
+}
+
+function normalizeSimpleAttributeType(simpleType) {
+  if (Array.isArray(simpleType)) return [...simpleType];
+  if (typeof simpleType !== 'string') return simpleType;
+  const relation = parseRelationType(simpleType);
+  if (!relation) return simpleType;
+  return `relation:${compactRelationTarget(relation.target)}:${relation.relType}`;
+}
+
+function isPlainObject(value) {
+  return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isLocaleKey(value) {
+  return typeof value === 'string' && /^[a-z]{2}(?:-[A-Z]{2})?$/.test(value);
+}
+
+function isSingleTypeLocaleMap(entries) {
+  if (!isPlainObject(entries)) return false;
+  const pairs = Object.entries(entries);
+  if (pairs.length === 0) return false;
+  return pairs.every(([key, value]) => isLocaleKey(key) && isPlainObject(value));
+}
+
+function validateSimpleAttributeType(simpleType, fieldPath) {
+  const errors = [];
+  const scalarTypes = new Set(['string', 'number', 'boolean', 'date', 'media', 'media[]', 'json']);
+  const relationTypes = new Set([
+    'oneToOne',
+    'oneToMany',
+    'manyToOne',
+    'manyToMany',
+    'oneWay',
+    'manyWay',
+    'morphOne',
+    'morphMany'
+  ]);
+
+  if (Array.isArray(simpleType)) {
+    const invalidItems = simpleType.filter((item) => typeof item !== 'string' || item.trim() === '');
+    if (invalidItems.length > 0) {
+      errors.push(`${fieldPath} must be an array of non-empty component UIDs`);
+    }
+    return errors;
+  }
+
+  if (typeof simpleType !== 'string') {
+    errors.push(`${fieldPath} must be a string or an array`);
+    return errors;
+  }
+
+  if (scalarTypes.has(simpleType)) return errors;
+
+  if (simpleType.startsWith('component:')) {
+    const parsed = parseComponentType(simpleType);
+    if (!parsed || !parsed.uid || !parsed.uid.includes('.')) {
+      errors.push(`${fieldPath} has invalid component syntax: ${simpleType}`);
+    }
+    return errors;
+  }
+
+  if (simpleType.startsWith('relation:')) {
+    const parsed = parseRelationType(simpleType);
+    if (!parsed || !parsed.target || !parsed.relType) {
+      errors.push(`${fieldPath} has invalid relation syntax: ${simpleType}`);
+      return errors;
+    }
+    if (!/^[a-z0-9-]+$/i.test(parsed.target)) {
+      errors.push(`${fieldPath} must use short relation syntax like relation:article:oneToMany`);
+    }
+    if (!relationTypes.has(parsed.relType)) {
+      errors.push(`${fieldPath} uses unsupported relation type "${parsed.relType}"`);
+    }
+    return errors;
+  }
+
+  errors.push(`${fieldPath} uses unsupported attribute type "${simpleType}"`);
+  return errors;
+}
+
+function flattenRelationValue(val) {
+  if (val == null) return null;
+  if (typeof val !== 'object') return val;
+  if ('data' in val) {
+    const data = val.data;
+    if (Array.isArray(data)) return data.map((e) => e?.id).filter((v) => v != null);
+    if (data && typeof data === 'object') return data.id ?? null;
+    return data;
+  }
+  return val;
+}
+
+const DZ_SYSTEM_KEYS = new Set(['createdAt', 'updatedAt', 'publishedAt', 'locale', 'localizations', 'createdBy', 'updatedBy']);
+
+function cleanDynamicZoneItem(item) {
+  if (!item || typeof item !== 'object') return item;
+  const result = {};
+  for (const [k, v] of Object.entries(item)) {
+    if (DZ_SYSTEM_KEYS.has(k)) continue;
+    if (v && typeof v === 'object' && 'data' in v) {
+      result[k] = flattenRelationValue(v);
+    } else {
+      result[k] = v;
+    }
+  }
+  return result;
+}
+
+function flattenStrapiEntry(entry) {
+  if (!entry || typeof entry !== 'object') return entry;
+  if (entry.attributes && typeof entry.attributes === 'object') {
+    return { id: entry.id, documentId: entry.documentId, ...entry.attributes };
+  }
+  return entry;
+}
+
+function entryToSnapshot(entry, schemaAttributes) {
+  const flat = flattenStrapiEntry(entry);
+  if (!flat || typeof flat !== 'object') return flat;
+  const isAttrsObj = !Array.isArray(schemaAttributes) && typeof schemaAttributes === 'object' && schemaAttributes !== null;
+  const keys = isAttrsObj
+    ? Object.keys(schemaAttributes)
+    : (Array.isArray(schemaAttributes) ? schemaAttributes : []);
+  const keep = new Set(keys.length ? keys : []);
+  if (Object.prototype.hasOwnProperty.call(flat, 'id')) keep.add('id');
+  const result = {};
+  for (const k of keep) {
+    const typeStr = isAttrsObj ? schemaAttributes[k] : null;
+    if (!Object.prototype.hasOwnProperty.call(flat, k)) {
+      if (typeStr && typeof typeStr === 'string' && typeStr.startsWith('relation:')) {
+        const parsed = parseRelationType(typeStr);
+        result[k] = parsed && (parsed.relType === 'oneToMany' || parsed.relType === 'manyToMany') ? [] : null;
+      } else if (typeStr === 'media') {
+        result[k] = null;
+      } else if (typeStr === 'media[]') {
+        result[k] = [];
+      } else if (Array.isArray(typeStr)) {
+        result[k] = [];
+      }
+      continue;
+    }
+    const val = flat[k];
+    if (typeStr && typeof typeStr === 'string' && typeStr.startsWith('relation:')) {
+      result[k] = flattenRelationValue(val);
+    } else if (Array.isArray(typeStr)) {
+      result[k] = Array.isArray(val) ? val.map(cleanDynamicZoneItem) : (val ?? []);
+    } else {
+      result[k] = val;
+    }
+  }
+  return result;
+}
+
+function valuesEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a === 'object' && typeof b === 'object') return JSON.stringify(a) === JSON.stringify(b);
+  return false;
+}
+
+function normalizeValueByType(value, typeStr) {
+  if (typeStr === 'media') return value ?? null;
+  if (typeStr === 'media[]') return Array.isArray(value) ? value : (value ?? []);
+  if (typeStr && typeof typeStr === 'string' && typeStr.startsWith('relation:')) {
+    if (value === undefined) {
+      const parsed = parseRelationType(typeStr);
+      return parsed && (parsed.relType === 'oneToMany' || parsed.relType === 'manyToMany') ? [] : null;
+    }
+    return flattenRelationValue(value);
+  }
+  if (Array.isArray(typeStr)) {
+    if (value === undefined) return [];
+    return Array.isArray(value) ? value.map(cleanDynamicZoneItem) : (value ?? []);
+  }
+  return value;
+}
+
+function entryDataDiffers(snapshotData, existingEntry, schemaKeysOrAttrs) {
+  if (!existingEntry || !snapshotData) return true;
+  const existing = flattenStrapiEntry(existingEntry);
+  const isAttrsObj = !Array.isArray(schemaKeysOrAttrs) && typeof schemaKeysOrAttrs === 'object' && schemaKeysOrAttrs !== null;
+  const keys = isAttrsObj
+    ? Object.keys(schemaKeysOrAttrs).filter((k) => k !== 'id' && Object.prototype.hasOwnProperty.call(snapshotData, k))
+    : (Array.isArray(schemaKeysOrAttrs)
+        ? schemaKeysOrAttrs.filter((k) => Object.prototype.hasOwnProperty.call(snapshotData, k))
+        : Object.keys(schemaKeysOrAttrs || snapshotData).filter((k) => k !== 'id'));
+  for (const k of keys) {
+    let snapshotVal = snapshotData[k];
+    let existingVal = existing[k];
+    const typeStr = isAttrsObj ? schemaKeysOrAttrs[k] : null;
+    snapshotVal = normalizeValueByType(snapshotVal, typeStr);
+    existingVal = normalizeValueByType(existingVal, typeStr);
+    if (!valuesEqual(snapshotVal, existingVal)) return true;
+  }
+  return false;
+}
+
+function entryDataDiff(snapshotData, existingEntry, schemaKeysOrAttrs) {
+  if (!existingEntry || !snapshotData) return snapshotData ? { ...snapshotData } : {};
+  const existing = flattenStrapiEntry(existingEntry);
+  const isAttrsObj = !Array.isArray(schemaKeysOrAttrs) && typeof schemaKeysOrAttrs === 'object' && schemaKeysOrAttrs !== null;
+  const keys = isAttrsObj
+    ? Object.keys(schemaKeysOrAttrs).filter((k) => k !== 'id' && Object.prototype.hasOwnProperty.call(snapshotData, k))
+    : (Array.isArray(schemaKeysOrAttrs)
+        ? schemaKeysOrAttrs.filter((k) => Object.prototype.hasOwnProperty.call(snapshotData, k))
+        : Object.keys(schemaKeysOrAttrs || snapshotData).filter((k) => k !== 'id'));
+  const diff = {};
+  for (const k of keys) {
+    let snapshotVal = snapshotData[k];
+    let existingVal = existing[k];
+    const typeStr = isAttrsObj ? schemaKeysOrAttrs[k] : null;
+    snapshotVal = normalizeValueByType(snapshotVal, typeStr);
+    existingVal = normalizeValueByType(existingVal, typeStr);
+    if (!valuesEqual(snapshotVal, existingVal)) diff[k] = snapshotData[k];
+  }
+  return diff;
+}
+
+function buildSampleFromSimpleAttributes(attributes) {
+  if (!attributes || typeof attributes !== 'object') return {};
+  const obj = {};
+  for (const [key, typeStr] of Object.entries(attributes)) {
+    const t = typeof typeStr === 'string' ? typeStr : 'json';
+    if (t === 'string') obj[key] = '';
+    else if (t === 'number') obj[key] = 0;
+    else if (t === 'boolean') obj[key] = false;
+    else if (t === 'date') obj[key] = null;
+    else if (t === 'media') obj[key] = null;
+    else if (t === 'media[]') obj[key] = [];
+    else if (t.startsWith('relation:')) {
+      const parsed = parseRelationType(t);
+      obj[key] = parsed && (parsed.relType === 'oneToMany' || parsed.relType === 'manyToMany') ? [] : null;
+    } else if (Array.isArray(t)) {
+      obj[key] = [];
+    } else {
+      obj[key] = {};
+    }
+  }
+  return obj;
+}
+
+function getContentTypeId(type) {
+  if (!type) return null;
+  const uid = type.uid || type.apiID || type.name;
+  if (typeof uid === 'string' && uid.includes('.')) return uid.split('.')[1];
+  return type.apiID || type.name;
+}
+
+function getEntryLocale(entry) {
+  return entry?.locale ?? entry?.localization?.locale ?? '';
+}
+
+function getSchemaKeysFromSnapshot(snapshotContentTypes, contentType) {
+  const attrs = snapshotContentTypes[contentType]?.attributes;
+  return attrs ? Object.keys(attrs) : [];
+}
+
+function getSchemaAttrsFromSnapshot(snapshotContentTypes, contentType) {
+  const attributes = snapshotContentTypes[contentType]?.attributes ?? {};
+  return Object.fromEntries(
+    Object.entries(attributes).map(([key, value]) => [key, normalizeSimpleAttributeType(value)])
+  );
+}
+
+function getComparableSchemaAttrs(attributes) {
+  if (!attributes || typeof attributes !== 'object' || Array.isArray(attributes)) return {};
+  return Object.fromEntries(
+    Object.entries(attributes).filter(([, typeStr]) => typeStr !== 'media' && typeStr !== 'media[]')
+  );
+}
+
+function stripIgnoredFields(data, schemaAttributes) {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) return data;
+  const comparableAttrs = getComparableSchemaAttrs(schemaAttributes);
+  if (Object.keys(comparableAttrs).length === Object.keys(schemaAttributes || {}).length) {
+    return { ...data };
+  }
+  return Object.fromEntries(
+    Object.entries(data).filter(([key]) => key === 'id' || key === 'documentId' || key in comparableAttrs)
+  );
+}
+
+function isLocalizedSnapshotBlock(block) {
+  if (!block || typeof block !== 'object') return false;
+  const entries = block.entries;
+  if (block.singleType === true) return isSingleTypeLocaleMap(entries);
+  return (
+    entries != null &&
+    typeof entries === 'object' &&
+    !Array.isArray(entries) &&
+    Object.keys(entries).length > 0
+  );
+}
+
+function hasSnapshotEntries(block) {
+  if (!block || typeof block !== 'object') return false;
+  const entries = block.entries;
+  if (block.singleType === true) {
+    if (!isPlainObject(entries)) return false;
+    if (isSingleTypeLocaleMap(entries)) return Object.keys(entries).length > 0;
+    return Object.keys(entries).length > 0;
+  }
+  if (Array.isArray(entries)) return entries.length > 0;
+  if (!entries || typeof entries !== 'object') return false;
+  return Object.values(entries).some((list) => Array.isArray(list) && list.length > 0);
+}
+
+module.exports = {
+  simplifyAttributeType,
+  parseComponentType,
+  parseRelationType,
+  parseDynamicZoneType,
+  validateSimpleAttributeType,
+  flattenRelationValue,
+  cleanDynamicZoneItem,
+  flattenStrapiEntry,
+  entryToSnapshot,
+  entryDataDiffers,
+  entryDataDiff,
+  buildSampleFromSimpleAttributes,
+  getContentTypeId,
+  getEntryLocale,
+  getSchemaKeysFromSnapshot,
+  getSchemaAttrsFromSnapshot,
+  normalizeSimpleAttributeType,
+  compactRelationTarget,
+  expandRelationTarget,
+  isPlainObject,
+  isSingleTypeLocaleMap,
+  getComparableSchemaAttrs,
+  stripIgnoredFields,
+  isLocalizedSnapshotBlock,
+  hasSnapshotEntries
+};