@intranefr/superbackend 1.4.3

package/src/services/headlessModels.service.js

@@ -0,0 +1,356 @@
+const mongoose = require('mongoose');
+const crypto = require('crypto');
+
+const HeadlessModelDefinition = require('../models/HeadlessModelDefinition');
+
+const MODEL_COLLECTION_PREFIX = 'headless_';
+
+function normalizeCodeIdentifier(codeIdentifier) {
+  const normalized = String(codeIdentifier || '').trim();
+  if (!normalized) {
+    const err = new Error('codeIdentifier is required');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+  if (!/^[a-z][a-z0-9_]*$/.test(normalized)) {
+    const err = new Error('codeIdentifier must match /^[a-z][a-z0-9_]*$/');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+  return normalized;
+}
+
+function computeSchemaHash({ fields, indexes }) {
+  return crypto
+    .createHash('sha256')
+    .update(JSON.stringify({ fields: fields || [], indexes: indexes || [] }))
+    .digest('hex');
+}
+
+function toMongooseField(field) {
+  const type = String(field.type || '').toLowerCase();
+  const base = {};
+
+  if (field.required) base.required = true;
+  if (field.unique) base.unique = true;
+  if (field.default !== undefined) base.default = field.default;
+
+  if (field.validation && typeof field.validation === 'object') {
+    if (field.validation.min !== undefined) base.min = field.validation.min;
+    if (field.validation.max !== undefined) base.max = field.validation.max;
+    if (field.validation.minLength !== undefined) base.minlength = field.validation.minLength;
+    if (field.validation.maxLength !== undefined) base.maxlength = field.validation.maxLength;
+    if (field.validation.enum !== undefined) base.enum = field.validation.enum;
+    if (field.validation.match !== undefined) base.match = field.validation.match;
+  }
+
+  if (type === 'string') return { ...base, type: String };
+  if (type === 'number') return { ...base, type: Number };
+  if (type === 'boolean') return { ...base, type: Boolean };
+  if (type === 'date') return { ...base, type: Date };
+
+  if (type === 'object') return { ...base, type: mongoose.Schema.Types.Mixed };
+  if (type === 'array') return { ...base, type: [mongoose.Schema.Types.Mixed] };
+
+  if (type === 'ref' || type === 'reference') {
+    const refModelCode = String(field.refModelCode || '').trim();
+    if (!refModelCode) {
+      const err = new Error(`Field ${field.name} is reference type but refModelCode is missing`);
+      err.code = 'VALIDATION';
+      throw err;
+    }
+    const refModelName = getMongooseModelName(refModelCode);
+    return { ...base, type: mongoose.Schema.Types.ObjectId, ref: refModelName };
+  }
+
+  if (type === 'ref[]' || type === 'ref_array' || type === 'refarray') {
+    const refModelCode = String(field.refModelCode || '').trim();
+    if (!refModelCode) {
+      const err = new Error(`Field ${field.name} is reference array type but refModelCode is missing`);
+      err.code = 'VALIDATION';
+      throw err;
+    }
+    const refModelName = getMongooseModelName(refModelCode);
+    return [{ ...base, type: mongoose.Schema.Types.ObjectId, ref: refModelName }];
+  }
+
+  const err = new Error(`Unsupported field type: ${field.type}`);
+  err.code = 'VALIDATION';
+  throw err;
+}
+
+function getMongooseModelName(codeIdentifier) {
+  const code = normalizeCodeIdentifier(codeIdentifier);
+  return `Headless_${code}`;
+}
+
+function getMongoCollectionName(codeIdentifier) {
+  const code = normalizeCodeIdentifier(codeIdentifier);
+  return `${MODEL_COLLECTION_PREFIX}${code}`;
+}
+
+function buildSchemaFromDefinition(def) {
+  const schemaShape = {};
+  for (const field of def.fields || []) {
+    const fieldName = String(field.name || '').trim();
+    if (!fieldName) continue;
+    if (fieldName === '_id') continue;
+
+    schemaShape[fieldName] = toMongooseField(field);
+  }
+
+  schemaShape._headlessModelCode = { type: String, default: def.codeIdentifier, index: true };
+  schemaShape._headlessSchemaVersion = { type: Number, default: def.version, index: true };
+
+  const schema = new mongoose.Schema(schemaShape, {
+    timestamps: true,
+    collection: getMongoCollectionName(def.codeIdentifier),
+    strict: false,
+  });
+
+  const indexes = Array.isArray(def.indexes) ? def.indexes : [];
+  for (const idx of indexes) {
+    if (!idx || typeof idx !== 'object') continue;
+    const fields = idx.fields;
+    if (!fields) continue;
+    const options = idx.options && typeof idx.options === 'object' ? idx.options : {};
+    schema.index(fields, options);
+  }
+
+  return schema;
+}
+
+async function ensureIndexesBestEffort(Model) {
+  try {
+    if (!Model || !Model.collection || typeof Model.collection.createIndex !== 'function') return;
+    const declared = Array.isArray(Model.schema && Model.schema.indexes)
+      ? Model.schema.indexes()
+      : [];
+    for (const idx of declared) {
+      const fields = idx && idx[0];
+      const options = idx && idx[1];
+      if (!fields) continue;
+      try {
+        await Model.collection.createIndex(fields, options || {});
+      } catch (e) {
+        // best-effort
+      }
+    }
+  } catch (e) {
+    // best-effort
+  }
+}
+
+async function listModelDefinitions() {
+  return HeadlessModelDefinition.find({ isActive: true }).sort({ updatedAt: -1 }).lean();
+}
+
+async function getModelDefinitionByCode(codeIdentifier) {
+  const code = normalizeCodeIdentifier(codeIdentifier);
+  return HeadlessModelDefinition.findOne({ codeIdentifier: code, isActive: true }).lean();
+}
+
+async function createModelDefinition(payload) {
+  const codeIdentifier = normalizeCodeIdentifier(payload.codeIdentifier);
+  const displayName = String(payload.displayName || codeIdentifier).trim();
+  if (!displayName) {
+    const err = new Error('displayName is required');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+
+  const fields = Array.isArray(payload.fields) ? payload.fields : [];
+  const indexes = Array.isArray(payload.indexes) ? payload.indexes : [];
+  const fieldsHash = computeSchemaHash({ fields, indexes });
+
+  const existing = await HeadlessModelDefinition.findOne({ codeIdentifier }).lean();
+  if (existing) {
+    const err = new Error('Model already exists');
+    err.code = 'CONFLICT';
+    throw err;
+  }
+
+  const doc = await HeadlessModelDefinition.create({
+    codeIdentifier,
+    displayName,
+    description: String(payload.description || ''),
+    fields,
+    indexes,
+    fieldsHash,
+    version: 1,
+    previousFields: [],
+    previousIndexes: [],
+    isActive: true,
+  });
+
+  return doc.toObject();
+}
+
+async function updateModelDefinition(codeIdentifier, updates) {
+  const code = normalizeCodeIdentifier(codeIdentifier);
+  const doc = await HeadlessModelDefinition.findOne({ codeIdentifier: code, isActive: true });
+  if (!doc) {
+    const err = new Error('Model not found');
+    err.code = 'NOT_FOUND';
+    throw err;
+  }
+
+  if (updates.displayName !== undefined) {
+    const displayName = String(updates.displayName || '').trim();
+    if (!displayName) {
+      const err = new Error('displayName is required');
+      err.code = 'VALIDATION';
+      throw err;
+    }
+    doc.displayName = displayName;
+  }
+
+  if (updates.description !== undefined) {
+    doc.description = String(updates.description || '');
+  }
+
+  if (updates.fields !== undefined) {
+    const fields = Array.isArray(updates.fields) ? updates.fields : [];
+    const indexes = Array.isArray(doc.indexes) ? doc.indexes : [];
+    const newHash = computeSchemaHash({ fields, indexes });
+    if (newHash !== doc.fieldsHash) {
+      doc.previousFields = doc.fields;
+      doc.fields = fields;
+      doc.fieldsHash = newHash;
+      doc.version = Number(doc.version || 1) + 1;
+    }
+  }
+
+  if (updates.indexes !== undefined) {
+    const nextIndexes = Array.isArray(updates.indexes) ? updates.indexes : [];
+    const fields = Array.isArray(doc.fields) ? doc.fields : [];
+    const newHash = computeSchemaHash({ fields, indexes: nextIndexes });
+    if (newHash !== doc.fieldsHash) {
+      doc.previousIndexes = doc.indexes;
+      doc.indexes = nextIndexes;
+      doc.fieldsHash = newHash;
+      doc.version = Number(doc.version || 1) + 1;
+    }
+  }
+
+  await doc.save();
+  return doc.toObject();
+}
+
+async function disableModelDefinition(codeIdentifier) {
+  const code = normalizeCodeIdentifier(codeIdentifier);
+  const doc = await HeadlessModelDefinition.findOne({ codeIdentifier: code, isActive: true });
+  if (!doc) {
+    const err = new Error('Model not found');
+    err.code = 'NOT_FOUND';
+    throw err;
+  }
+
+  doc.isActive = false;
+  await doc.save();
+  return doc.toObject();
+}
+
+const modelCache = new Map();
+
+async function ensureAutoMigration(modelDef) {
+  const collectionName = getMongoCollectionName(modelDef.codeIdentifier);
+  const coll = mongoose.connection.collection(collectionName);
+
+  const currentFields = Array.isArray(modelDef.fields) ? modelDef.fields : [];
+  const previousFields = Array.isArray(modelDef.previousFields) ? modelDef.previousFields : [];
+
+  const currentFieldNames = new Set(
+    currentFields
+      .map((f) => String(f?.name || '').trim())
+      .filter((n) => n && n !== '_id'),
+  );
+  const previousFieldNames = new Set(
+    previousFields
+      .map((f) => String(f?.name || '').trim())
+      .filter((n) => n && n !== '_id'),
+  );
+
+  const addedFields = currentFields.filter((f) => {
+    const n = String(f?.name || '').trim();
+    return n && !previousFieldNames.has(n);
+  });
+
+  const removedFieldNames = Array.from(previousFieldNames).filter((n) => !currentFieldNames.has(n));
+
+  const setOps = { _headlessSchemaVersion: modelDef.version };
+  const unsetOps = {};
+
+  for (const f of addedFields) {
+    const name = String(f?.name || '').trim();
+    if (!name) continue;
+    if (f.default !== undefined) {
+      setOps[name] = f.default;
+    }
+  }
+
+  for (const name of removedFieldNames) {
+    unsetOps[name] = '';
+  }
+
+  const update = { $set: setOps };
+  if (Object.keys(unsetOps).length > 0) update.$unset = unsetOps;
+
+  const filter = { _headlessSchemaVersion: { $ne: modelDef.version } };
+  if (addedFields.length > 0) {
+    filter.$or = [
+      { _headlessSchemaVersion: { $ne: modelDef.version } },
+      ...addedFields
+        .map((f) => String(f?.name || '').trim())
+        .filter((n) => n)
+        .map((name) => ({ [name]: { $exists: false } })),
+    ];
+  }
+
+  await coll.updateMany(filter, update);
+}
+
+async function getDynamicModel(codeIdentifier) {
+  const def = await getModelDefinitionByCode(codeIdentifier);
+  if (!def) {
+    const err = new Error('Model not found');
+    err.code = 'NOT_FOUND';
+    throw err;
+  }
+
+  const cacheKey = `${def.codeIdentifier}:${def.version}:${def.fieldsHash}`;
+  const cached = modelCache.get(cacheKey);
+  if (cached) return cached;
+
+  const modelName = getMongooseModelName(def.codeIdentifier);
+
+  if (mongoose.models[modelName]) {
+    delete mongoose.models[modelName];
+  }
+  if (mongoose.modelSchemas && mongoose.modelSchemas[modelName]) {
+    delete mongoose.modelSchemas[modelName];
+  }
+
+  const schema = buildSchemaFromDefinition(def);
+  const Model = mongoose.model(modelName, schema);
+
+  await ensureAutoMigration(def);
+  await ensureIndexesBestEffort(Model);
+
+  modelCache.set(cacheKey, Model);
+  return Model;
+}
+
+module.exports = {
+  MODEL_COLLECTION_PREFIX,
+  normalizeCodeIdentifier,
+  getMongooseModelName,
+  getMongoCollectionName,
+  computeSchemaHash,
+  listModelDefinitions,
+  getModelDefinitionByCode,
+  createModelDefinition,
+  updateModelDefinition,
+  disableModelDefinition,
+  getDynamicModel,
+};

package/src/services/i18n.service.js

@@ -0,0 +1,314 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const I18nLocale = require('../models/I18nLocale');
+const I18nEntry = require('../models/I18nEntry');
+const { getSettingValue } = require('./globalSettings.service');
+const { createAuditEvent } = require('./audit.service');
+
+const cache = new Map();
+const CACHE_TTL = 30000;
+
+function stableStringify(value) {
+  if (value === null || value === undefined) return '';
+  if (typeof value === 'string') return value;
+  return JSON.stringify(value);
+}
+
+function sha256Base64(value) {
+  return crypto.createHash('sha256').update(String(value), 'utf8').digest('base64');
+}
+
+function flattenJson(obj, prefix = '', out = {}) {
+  if (obj === null || obj === undefined) {
+    return out;
+  }
+
+  if (typeof obj !== 'object' || Array.isArray(obj)) {
+    out[prefix] = stableStringify(obj);
+    return out;
+  }
+
+  for (const [k, v] of Object.entries(obj)) {
+    const nextPrefix = prefix ? `${prefix}.${k}` : k;
+    if (v !== null && typeof v === 'object' && !Array.isArray(v)) {
+      flattenJson(v, nextPrefix, out);
+    } else {
+      out[nextPrefix] = stableStringify(v);
+    }
+  }
+
+  return out;
+}
+
+function interpolate(template, vars = {}) {
+  const str = String(template || '');
+  return str.replace(/\{([a-zA-Z0-9_\-\.]+)\}/g, (match, key) => {
+    if (Object.prototype.hasOwnProperty.call(vars, key)) {
+      return String(vars[key]);
+    }
+    return match;
+  });
+}
+
+async function getDefaultLocaleCode() {
+  const envDefault = process.env.I18N_DEFAULT_LOCALE;
+  if (envDefault) return envDefault;
+
+  const fromSettings = await getSettingValue('i18n.defaultLocale', null);
+  if (fromSettings) return fromSettings;
+
+  const localeDoc = await I18nLocale.findOne({ isDefault: true }).lean();
+  if (localeDoc?.code) return localeDoc.code;
+
+  const anyEnabled = await I18nLocale.findOne({ enabled: true }).sort({ code: 1 }).lean();
+  if (anyEnabled?.code) return anyEnabled.code;
+
+  return 'en';
+}
+
+function resolveLocaleFromRequest(req) {
+  const cookieHeader = req.headers?.cookie;
+  if (typeof cookieHeader === 'string' && cookieHeader.length > 0) {
+    const parts = cookieHeader.split(';').map((p) => p.trim());
+    for (const part of parts) {
+      const idx = part.indexOf('=');
+      if (idx === -1) continue;
+      const k = part.slice(0, idx).trim();
+      const v = part.slice(idx + 1).trim();
+      if (k === 'lang' && v) {
+        try {
+          return decodeURIComponent(v);
+        } catch (e) {
+          return v;
+        }
+      }
+    }
+  }
+
+  const queryLocale = req.query?.lang;
+  if (queryLocale) return queryLocale;
+
+  const header = req.headers['accept-language'];
+  if (typeof header === 'string' && header.length > 0) {
+    const primary = header.split(',')[0].trim();
+    if (primary) return primary.split(';')[0].trim();
+  }
+
+  return null;
+}
+
+async function getBundle(locale) {
+  const effectiveLocale = locale || (await getDefaultLocaleCode());
+
+  const cached = cache.get(`bundle:${effectiveLocale}`);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+    return cached.value;
+  }
+
+  const entries = await I18nEntry.find({ locale: effectiveLocale }).select('key value').lean();
+  const map = {};
+  for (const e of entries) {
+    map[e.key] = e.value;
+  }
+
+  const value = {
+    locale: effectiveLocale,
+    defaultLocale: await getDefaultLocaleCode(),
+    entries: map,
+  };
+
+  cache.set(`bundle:${effectiveLocale}`, { value, timestamp: Date.now() });
+  return value;
+}
+
+async function t({ key, locale, vars, html, defaultValue }) {
+  const effectiveLocale = locale || (await getDefaultLocaleCode());
+  const defaultLocale = await getDefaultLocaleCode();
+
+  const cacheKey = `entry:${effectiveLocale}:${key}`;
+  const cached = cache.get(cacheKey);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+    const value = cached.value;
+    const text = interpolate(value?.value ?? defaultValue ?? key, vars);
+    return { text, html: html === true || value?.valueFormat === 'html' };
+  }
+
+  let entry = await I18nEntry.findOne({ key, locale: effectiveLocale }).lean();
+  if (!entry && defaultLocale && defaultLocale !== effectiveLocale) {
+    entry = await I18nEntry.findOne({ key, locale: defaultLocale }).lean();
+  }
+
+  cache.set(cacheKey, { value: entry || null, timestamp: Date.now() });
+  const text = interpolate(entry?.value ?? defaultValue ?? key, vars);
+  return { text, html: html === true || entry?.valueFormat === 'html' };
+}
+
+function clearI18nCache() {
+  cache.clear();
+}
+
+async function ensureLocalesExist(locales) {
+  const existing = await I18nLocale.find({ code: { $in: locales } }).lean();
+  const existingSet = new Set(existing.map((l) => l.code));
+
+  const toCreate = locales
+    .filter((c) => !existingSet.has(c))
+    .map((code) => ({ code, name: code.toUpperCase(), enabled: true, isDefault: false }));
+
+  if (toCreate.length > 0) {
+    await I18nLocale.insertMany(toCreate);
+  }
+
+  const hasDefault = await I18nLocale.findOne({ isDefault: true }).lean();
+  if (!hasDefault) {
+    const first = locales[0];
+    if (first) {
+      await I18nLocale.updateOne({ code: first }, { $set: { isDefault: true } });
+      await I18nLocale.updateMany({ code: { $ne: first } }, { $set: { isDefault: false } });
+    }
+  }
+}
+
+async function seedFromJsonFiles({
+  baseDir,
+  locales,
+  seedVersion,
+  actorType = 'system',
+  actorId = null,
+}) {
+  if (!baseDir) {
+    throw new Error('baseDir is required');
+  }
+  if (!Array.isArray(locales) || locales.length === 0) {
+    throw new Error('locales is required');
+  }
+
+  await ensureLocalesExist(locales);
+
+  const summary = {
+    inserted: 0,
+    updated: 0,
+    skippedEdited: 0,
+    skippedExists: 0,
+    locales: {},
+  };
+
+  for (const locale of locales) {
+    const filePath = path.join(baseDir, `${locale}.json`);
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const json = JSON.parse(raw);
+    const flat = flattenJson(json);
+
+    summary.locales[locale] = { inserted: 0, updated: 0, skippedEdited: 0, skippedExists: 0 };
+
+    for (const [key, value] of Object.entries(flat)) {
+      const nextSeedHash = sha256Base64(value);
+      const existing = await I18nEntry.findOne({ key, locale });
+
+      if (!existing) {
+        await I18nEntry.create({
+          key,
+          locale,
+          value,
+          valueFormat: 'text',
+          source: 'seed',
+          seeded: true,
+          seedHash: nextSeedHash,
+          seedVersion: seedVersion || null,
+          edited: false,
+        });
+        summary.inserted += 1;
+        summary.locales[locale].inserted += 1;
+        continue;
+      }
+
+      if (existing.edited === true) {
+        summary.skippedEdited += 1;
+        summary.locales[locale].skippedEdited += 1;
+        continue;
+      }
+
+      if (existing.seeded === true) {
+        existing.value = value;
+        existing.seedHash = nextSeedHash;
+        existing.seedVersion = seedVersion || existing.seedVersion || null;
+        existing.source = 'seed';
+        await existing.save();
+        summary.updated += 1;
+        summary.locales[locale].updated += 1;
+        continue;
+      }
+
+      summary.skippedExists += 1;
+      summary.locales[locale].skippedExists += 1;
+    }
+
+    clearI18nCache();
+  }
+
+  await createAuditEvent({
+    actorType,
+    actorId,
+    action: 'i18n.seed',
+    entityType: 'I18nEntry',
+    entityId: null,
+    before: null,
+    after: summary,
+    meta: { locales, seedVersion: seedVersion || null },
+  });
+
+  return summary;
+}
+
+function createI18nMiddleware() {
+  return async (req, res, next) => {
+    try {
+      const resolved = resolveLocaleFromRequest(req);
+      const defaultLocale = await getDefaultLocaleCode();
+      const locale = resolved || defaultLocale;
+
+      res.locals.locale = locale;
+      res.locals.defaultLocale = defaultLocale;
+
+      const bundle = await getBundle(locale);
+      const defaultBundle =
+        defaultLocale && defaultLocale !== locale
+          ? await getBundle(defaultLocale)
+          : bundle;
+
+      res.locals.t = (key, vars, opts) => {
+        const useLocale = opts?.locale || locale;
+        const useBundle = useLocale === locale ? bundle : null;
+        const useDefaultBundle =
+          defaultLocale && useLocale !== defaultLocale ? defaultBundle : defaultBundle;
+
+        const raw =
+          useBundle?.entries?.[key] ??
+          useDefaultBundle?.entries?.[key] ??
+          opts?.defaultValue ??
+          key;
+
+        return interpolate(raw, vars || {});
+      };
+
+      next();
+    } catch (e) {
+      next(e);
+    }
+  };
+}
+
+module.exports = {
+  getDefaultLocaleCode,
+  resolveLocaleFromRequest,
+  getBundle,
+  t,
+  clearI18nCache,
+  seedFromJsonFiles,
+  createI18nMiddleware,
+  interpolate,
+  flattenJson,
+  sha256Base64,
+};