@intranefr/superbackend 1.4.3

package/src/services/i18nInferredKeys.service.js

@@ -0,0 +1,337 @@
+const fs = require('fs');
+const path = require('path');
+const ejs = require('ejs');
+const cheerio = require('cheerio');
+
+const cache = {
+  timestamp: 0,
+  ttlMs: 30000,
+  signature: '',
+  keys: [],
+  entries: {},
+};
+
+function toPosixPath(p) {
+  return String(p).split(path.sep).join('/');
+}
+
+function escapeRegex(s) {
+  return String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function patternToRegex(pattern) {
+  // Minimal .gitignore-like glob to regex:
+  // - supports *, ?, **
+  // - supports leading '/' (anchored at repo root)
+  // - supports trailing '/' (directory prefix)
+  const anchored = pattern.startsWith('/');
+  let p = anchored ? pattern.slice(1) : pattern;
+  const dirOnly = p.endsWith('/');
+  if (dirOnly) p = p.slice(0, -1);
+
+  let re = '';
+  for (let i = 0; i < p.length; i += 1) {
+    const ch = p[i];
+    const next = p[i + 1];
+
+    if (ch === '*' && next === '*') {
+      re += '.*';
+      i += 1;
+      continue;
+    }
+    if (ch === '*') {
+      re += '[^/]*';
+      continue;
+    }
+    if (ch === '?') {
+      re += '[^/]';
+      continue;
+    }
+
+    re += escapeRegex(ch);
+  }
+
+  if (anchored) {
+    // Match from root
+    return new RegExp(`^${re}${dirOnly ? '(/|$)' : '$'}`);
+  }
+
+  // Match anywhere in the path
+  return new RegExp(`(^|/)${re}${dirOnly ? '(/|$)' : '$'}`);
+}
+
+function loadGitignoreMatchers(rootDir) {
+  const ignoreFile = path.join(rootDir, '.gitignore');
+  if (!fs.existsSync(ignoreFile)) {
+    return [];
+  }
+
+  let raw = '';
+  try {
+    raw = fs.readFileSync(ignoreFile, 'utf8');
+  } catch {
+    return [];
+  }
+
+  const lines = raw.split(/\r?\n/);
+  const matchers = [];
+  for (const lineRaw of lines) {
+    const line = String(lineRaw || '').trim();
+    if (!line) continue;
+    if (line.startsWith('#')) continue;
+
+    // Negation is not supported in this lightweight matcher.
+    if (line.startsWith('!')) continue;
+
+    matchers.push(patternToRegex(line));
+  }
+  return matchers;
+}
+
+function createIgnoreFn(rootDir) {
+  const rootPosix = toPosixPath(rootDir);
+  const matchers = loadGitignoreMatchers(rootDir);
+
+  return function isIgnored(absPath) {
+    const rel = toPosixPath(path.relative(rootDir, absPath));
+    if (!rel || rel === '.') return false;
+
+    // Always ignore these.
+    if (rel === 'node_modules' || rel.startsWith('node_modules/')) return true;
+    if (rel === '.git' || rel.startsWith('.git/')) return true;
+
+    // Apply .gitignore matchers
+    for (const re of matchers) {
+      if (re.test(rel)) return true;
+    }
+
+    // Also ignore any path that escapes root (defensive)
+    const absPosix = toPosixPath(absPath);
+    if (!absPosix.startsWith(rootPosix)) return true;
+
+    return false;
+  };
+}
+
+function parseDirList(raw) {
+  if (!raw) return [];
+  return String(raw)
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+function getDefaultScanDirs() {
+  const envDirs = parseDirList(process.env.I18N_SCAN_VIEW_DIRS);
+  if (envDirs.length > 0) return envDirs;
+
+  // Generic default: scan the repository root (cwd) recursively.
+  return [process.cwd()];
+}
+
+function walkFilesSync(dir, out, ignoreFn) {
+  if (!fs.existsSync(dir)) return;
+  if (ignoreFn && ignoreFn(dir)) return;
+
+  const stat = fs.statSync(dir);
+  if (!stat.isDirectory()) return;
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const ent of entries) {
+    const full = path.join(dir, ent.name);
+    if (ent.isDirectory()) {
+      if (ent.name === 'node_modules' || ent.name === '.git') continue;
+      if (ignoreFn && ignoreFn(full)) continue;
+      walkFilesSync(full, out, ignoreFn);
+      continue;
+    }
+
+    if (ent.isFile() && ent.name.endsWith('.ejs')) {
+      if (ignoreFn && ignoreFn(full)) continue;
+      try {
+        const st = fs.statSync(full);
+        out.push({ filePath: full, mtimeMs: st.mtimeMs, size: st.size });
+      } catch {
+        // ignore
+      }
+    }
+  }
+}
+
+function computeSignature(files) {
+  return files
+    .map((f) => `${f.filePath}:${f.mtimeMs}:${f.size}`)
+    .sort()
+    .join('|');
+}
+
+function extractKeysFromEjsSource(src, { includeTCalls }) {
+  const keys = new Set();
+
+  // data-i18n-key="..." or '...'
+  const datasetRe = /data-i18n-key\s*=\s*(["'])([^"']+)\1/g;
+  for (let m = datasetRe.exec(src); m; m = datasetRe.exec(src)) {
+    const key = String(m[2] || '').trim();
+    if (key) keys.add(key);
+  }
+
+  if (includeTCalls) {
+    // t('foo.bar') or t("foo.bar")
+    const tCallRe = /\bt\s*\(\s*(["'])([^"']+)\1\s*[\),]/g;
+    for (let m = tCallRe.exec(src); m; m = tCallRe.exec(src)) {
+      const key = String(m[2] || '').trim();
+      if (key) keys.add(key);
+    }
+  }
+
+  return Array.from(keys);
+}
+
+function normalizeText(value) {
+  return String(value || '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function buildDefaultEjsLocals(filename) {
+  return {
+    title: '',
+    description: '',
+    canonicalUrl: '',
+    robots: '',
+    publicUrl: '',
+    assetVersion: '',
+    i18nInjectMeta: '0',
+    locale: 'fr',
+    defaultLocale: 'fr',
+    t: (key, vars, opts) => {
+      if (opts && typeof opts.defaultValue === 'string') return opts.defaultValue;
+      return key;
+    },
+    // Some templates expect an app root Vue mount; keep it minimal.
+    state: {},
+    filename,
+  };
+}
+
+function inferEntriesFromRenderedHtml(html) {
+  const $ = cheerio.load(String(html || ''), { decodeEntities: false });
+  const out = {};
+
+  $('[data-i18n-key]').each((_, el) => {
+    const key = $(el).attr('data-i18n-key');
+    if (!key) return;
+
+    const attrList = $(el).attr('data-i18n-attr');
+    const wantsHtml = $(el).is('[data-i18n-html]');
+
+    if (attrList) {
+      const attrs = String(attrList)
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+      if (attrs.length === 0) return;
+
+      // Store the first attribute value as the inferred default.
+      const a = attrs[0];
+      const v = $(el).attr(a);
+      if (typeof v !== 'string' || v.trim() === '') return;
+
+      out[key] = { value: v, valueFormat: 'text' };
+      return;
+    }
+
+    if (wantsHtml) {
+      const v = $(el).html();
+      if (typeof v !== 'string' || v.trim() === '') return;
+      out[key] = { value: v.trim(), valueFormat: 'html' };
+      return;
+    }
+
+    const txt = normalizeText($(el).text());
+    if (!txt) return;
+    out[key] = { value: txt, valueFormat: 'text' };
+  });
+
+  return out;
+}
+
+function scanOnce({ viewDirs, includeTCalls }) {
+  const dirs = Array.isArray(viewDirs) && viewDirs.length > 0 ? viewDirs : getDefaultScanDirs();
+
+  const rootDir = process.cwd();
+  const ignoreFn = createIgnoreFn(rootDir);
+
+  const files = [];
+  for (const d of dirs) {
+    const abs = path.isAbsolute(d) ? d : path.join(process.cwd(), d);
+    walkFilesSync(abs, files, ignoreFn);
+  }
+
+  const signature = computeSignature(files);
+  const now = Date.now();
+
+  if (cache.keys.length > 0 && cache.signature === signature && now - cache.timestamp < cache.ttlMs) {
+    return cache.keys;
+  }
+
+  const keys = new Set();
+  const inferredEntries = {};
+  for (const f of files) {
+    try {
+      const src = fs.readFileSync(f.filePath, 'utf8');
+      const extracted = extractKeysFromEjsSource(src, { includeTCalls });
+      for (const k of extracted) keys.add(k);
+
+      // Render then parse to infer default values (best-effort)
+      try {
+        const rendered = ejs.render(src, buildDefaultEjsLocals(f.filePath), { filename: f.filePath });
+        const nextEntries = inferEntriesFromRenderedHtml(rendered);
+        for (const [k, v] of Object.entries(nextEntries)) {
+          // First value wins (deterministic due to file ordering by signature sort)
+          if (!inferredEntries[k]) inferredEntries[k] = v;
+        }
+      } catch {
+        // If render fails, we still keep keys extracted from the raw source.
+      }
+    } catch {
+      // ignore file read errors
+    }
+  }
+
+  const sorted = Array.from(keys).sort();
+  cache.keys = sorted;
+  cache.entries = inferredEntries;
+  cache.signature = signature;
+  cache.timestamp = now;
+
+  return sorted;
+}
+
+function getInferredI18nKeys(options = {}) {
+  return scanOnce({
+    viewDirs: options.viewDirs,
+    includeTCalls: options.includeTCalls === true,
+  });
+}
+
+function getInferredI18nEntries(options = {}) {
+  scanOnce({
+    viewDirs: options.viewDirs,
+    includeTCalls: options.includeTCalls === true,
+  });
+  return cache.entries || {};
+}
+
+function clearInferredI18nKeysCache() {
+  cache.timestamp = 0;
+  cache.signature = '';
+  cache.keys = [];
+  cache.entries = {};
+}
+
+module.exports = {
+  getInferredI18nKeys,
+  getInferredI18nEntries,
+  clearInferredI18nKeysCache,
+};

package/src/services/jsonConfigs.service.js

@@ -0,0 +1,392 @@
+const crypto = require('crypto');
+
+const JsonConfig = require('../models/JsonConfig');
+
+const cache = new Map();
+
+function normalizeSlugBase(title) {
+  const str = String(title || '').trim().toLowerCase();
+  if (!str) return 'config';
+
+  const slug = str
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/(^-|-$)/g, '')
+    .replace(/-{2,}/g, '-');
+
+  return slug || 'config';
+}
+
+function randomSuffix4() {
+  return crypto.randomBytes(2).toString('hex');
+}
+
+async function generateUniqueSlugFromTitle(title, { maxAttempts = 10 } = {}) {
+  const base = normalizeSlugBase(title);
+
+  for (let i = 0; i < maxAttempts; i += 1) {
+    const candidate = `${base}-${randomSuffix4()}`;
+    // eslint-disable-next-line no-await-in-loop
+    const existing = await JsonConfig.findOne({ slug: candidate }).select('_id').lean();
+    if (!existing) return candidate;
+  }
+
+  throw new Error('Failed to generate unique slug');
+}
+
+function normalizeAlias(alias) {
+  const str = String(alias || '').trim().toLowerCase();
+  if (!str) return '';
+
+  const normalized = str
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/(^-|-$)/g, '')
+    .replace(/-{2,}/g, '-');
+
+  return normalized;
+}
+
+async function validateAliasUniqueness(alias, excludeId = null) {
+  if (!alias) return true;
+
+  const normalizedAlias = normalizeAlias(alias);
+  if (!normalizedAlias) return false;
+
+  const query = {
+    $or: [
+      { slug: normalizedAlias },
+      { alias: normalizedAlias }
+    ]
+  };
+
+  if (excludeId) {
+    query._id = { $ne: excludeId };
+  }
+
+  const existing = await JsonConfig.findOne(query).select('_id').lean();
+  return !existing;
+}
+
+function computeJsonHash(jsonRaw) {
+  return crypto.createHash('sha256').update(String(jsonRaw || ''), 'utf8').digest('hex');
+}
+
+function parseJsonOrThrow(jsonRaw) {
+  try {
+    return JSON.parse(String(jsonRaw));
+  } catch (e) {
+    const msg = e && e.message ? e.message : 'Invalid JSON';
+    const err = new Error(msg);
+    err.code = 'INVALID_JSON';
+    throw err;
+  }
+}
+
+function getCached(slug) {
+  const entry = cache.get(slug);
+  if (!entry) return null;
+  if (typeof entry.expiresAt === 'number' && Date.now() > entry.expiresAt) {
+    cache.delete(slug);
+    return null;
+  }
+  return entry.value;
+}
+
+function setCached(slug, value, ttlSeconds) {
+  const ttl = Number(ttlSeconds || 0);
+  if (Number.isNaN(ttl) || ttl <= 0) return;
+  cache.set(slug, { value, expiresAt: Date.now() + ttl * 1000 });
+}
+
+function clearJsonConfigCache(slug) {
+  if (!slug) return;
+  cache.delete(String(slug));
+}
+
+function clearAllJsonConfigCache() {
+  cache.clear();
+}
+
+async function listJsonConfigs() {
+  return JsonConfig.find()
+    .sort({ updatedAt: -1 })
+    .select('title slug alias publicEnabled cacheTtlSeconds updatedAt createdAt')
+    .lean();
+}
+
+async function getJsonConfigById(id) {
+  return JsonConfig.findById(id).lean();
+}
+
+async function createJsonConfig({ title, jsonRaw, publicEnabled = false, cacheTtlSeconds = 0, alias }) {
+  console.log('createJsonConfig called with:', { title, jsonRaw, publicEnabled, cacheTtlSeconds, alias });
+  
+  const normalizedTitle = String(title || '').trim();
+  if (!normalizedTitle) {
+    const err = new Error('title is required');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+
+  if (jsonRaw === undefined || jsonRaw === null) {
+    const err = new Error('jsonRaw is required');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+
+  parseJsonOrThrow(jsonRaw);
+
+  let normalizedAlias = null;
+  if (alias !== undefined && alias !== null) {
+    normalizedAlias = normalizeAlias(alias);
+    console.log('Normalized alias:', normalizedAlias);
+    if (normalizedAlias && !(await validateAliasUniqueness(normalizedAlias))) {
+      const err = new Error('Alias must be unique and not conflict with existing slugs or aliases');
+      err.code = 'ALIAS_NOT_UNIQUE';
+      throw err;
+    }
+  }
+
+  const slug = await generateUniqueSlugFromTitle(normalizedTitle);
+
+  const createData = {
+    title: normalizedTitle,
+    slug,
+    alias: normalizedAlias || undefined,
+    publicEnabled: Boolean(publicEnabled),
+    cacheTtlSeconds: Number(cacheTtlSeconds || 0) || 0,
+    jsonRaw: String(jsonRaw),
+    jsonHash: computeJsonHash(String(jsonRaw)),
+  };
+  
+  console.log('Creating document with data:', createData);
+
+  const doc = await JsonConfig.create(createData);
+  console.log('Created document:', doc.toObject());
+
+  clearJsonConfigCache(slug);
+  if (normalizedAlias) {
+    clearJsonConfigCache(normalizedAlias);
+  }
+  return doc.toObject();
+}
+
+async function updateJsonConfig(id, patch) {
+  console.log('updateJsonConfig called with id:', id, 'patch:', patch);
+  
+  const doc = await JsonConfig.findById(id);
+  if (!doc) {
+    const err = new Error('JSON config not found');
+    err.code = 'NOT_FOUND';
+    throw err;
+  }
+
+  console.log('Found document:', doc.toObject());
+
+  const oldSlug = doc.slug;
+  const oldAlias = doc.alias;
+
+  if (patch && Object.prototype.hasOwnProperty.call(patch, 'title')) {
+    const title = String(patch.title || '').trim();
+    if (!title) {
+      const err = new Error('title is required');
+      err.code = 'VALIDATION';
+      throw err;
+    }
+    doc.title = title;
+  }
+
+  if (patch && Object.prototype.hasOwnProperty.call(patch, 'publicEnabled')) {
+    doc.publicEnabled = Boolean(patch.publicEnabled);
+  }
+
+  if (patch && Object.prototype.hasOwnProperty.call(patch, 'cacheTtlSeconds')) {
+    const ttl = Number(patch.cacheTtlSeconds || 0);
+    doc.cacheTtlSeconds = Number.isNaN(ttl) ? 0 : Math.max(0, ttl);
+  }
+
+  if (patch && Object.prototype.hasOwnProperty.call(patch, 'jsonRaw')) {
+    if (patch.jsonRaw === null || patch.jsonRaw === undefined) {
+      const err = new Error('jsonRaw is required');
+      err.code = 'VALIDATION';
+      throw err;
+    }
+
+    parseJsonOrThrow(patch.jsonRaw);
+    doc.jsonRaw = String(patch.jsonRaw);
+    doc.jsonHash = computeJsonHash(doc.jsonRaw);
+  }
+
+  if (patch && Object.prototype.hasOwnProperty.call(patch, 'alias')) {
+    const newAlias = patch.alias;
+    console.log('Processing alias update. newAlias:', newAlias);
+    
+    if (newAlias === null || newAlias === undefined || newAlias === '') {
+      doc.alias = undefined;
+      console.log('Setting alias to undefined');
+    } else {
+      const normalizedAlias = normalizeAlias(newAlias);
+      console.log('Normalized alias for update:', normalizedAlias);
+      
+      if (!normalizedAlias) {
+        const err = new Error('Invalid alias format');
+        err.code = 'VALIDATION';
+        throw err;
+      }
+      
+      if (!(await validateAliasUniqueness(normalizedAlias, id))) {
+        const err = new Error('Alias must be unique and not conflict with existing slugs or aliases');
+        err.code = 'ALIAS_NOT_UNIQUE';
+        throw err;
+      }
+      
+      doc.alias = normalizedAlias;
+      console.log('Setting alias to:', normalizedAlias);
+    }
+  }
+
+  if (!doc.slug || String(doc.slug).trim() === '') {
+    doc.slug = await generateUniqueSlugFromTitle(doc.title);
+  }
+
+  console.log('Document before save:', doc.toObject());
+  await doc.save();
+  console.log('Document after save:', doc.toObject());
+
+  clearJsonConfigCache(oldSlug);
+  clearJsonConfigCache(doc.slug);
+  if (oldAlias) {
+    clearJsonConfigCache(oldAlias);
+  }
+  if (doc.alias) {
+    clearJsonConfigCache(doc.alias);
+  }
+  return doc.toObject();
+}
+
+async function regenerateJsonConfigSlug(id) {
+  const doc = await JsonConfig.findById(id);
+  if (!doc) {
+    const err = new Error('JSON config not found');
+    err.code = 'NOT_FOUND';
+    throw err;
+  }
+
+  const oldSlug = doc.slug;
+  doc.slug = await generateUniqueSlugFromTitle(doc.title);
+  await doc.save();
+
+  clearJsonConfigCache(oldSlug);
+  clearJsonConfigCache(doc.slug);
+  return doc.toObject();
+}
+
+async function deleteJsonConfig(id) {
+  const doc = await JsonConfig.findByIdAndDelete(id).lean();
+  if (!doc) {
+    const err = new Error('JSON config not found');
+    err.code = 'NOT_FOUND';
+    throw err;
+  }
+
+  clearJsonConfigCache(doc.slug);
+  return { success: true };
+}
+
+async function getJsonConfigValueBySlug(slug, opts = {}) {
+  const key = String(slug || '').trim();
+  if (!key) {
+    const err = new Error('slug is required');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+
+  const bypassCache = Boolean(opts.bypassCache);
+
+  if (!bypassCache) {
+    const cached = getCached(key);
+    if (cached !== null) return cached;
+  }
+
+  const doc = await JsonConfig.findOne({
+    $or: [
+      { slug: key },
+      { alias: key }
+    ]
+  }).lean();
+  
+  if (!doc) {
+    const err = new Error('JSON config not found');
+    err.code = 'NOT_FOUND';
+    throw err;
+  }
+
+  const data = parseJsonOrThrow(doc.jsonRaw);
+
+  // Cache under both the slug and the lookup key
+  setCached(key, data, doc.cacheTtlSeconds);
+  if (doc.slug !== key) {
+    setCached(doc.slug, data, doc.cacheTtlSeconds);
+  }
+  if (doc.alias && doc.alias !== key) {
+    setCached(doc.alias, data, doc.cacheTtlSeconds);
+  }
+
+  return data;
+}
+
+async function getJsonConfigPublicPayload(slug, { raw = false } = {}) {
+  const key = String(slug || '').trim();
+  if (!key) {
+    const err = new Error('slug is required');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+
+  const doc = await JsonConfig.findOne({
+    $or: [
+      { slug: key },
+      { alias: key }
+    ]
+  }).lean();
+
+  if (!doc || doc.publicEnabled !== true) {
+    const err = new Error('JSON config not found');
+    err.code = 'NOT_FOUND';
+    throw err;
+  }
+
+  const data = await getJsonConfigValueBySlug(doc.slug);
+
+  if (!raw) return data;
+
+  return {
+    slug: doc.slug,
+    alias: doc.alias,
+    title: doc.title,
+    publicEnabled: Boolean(doc.publicEnabled),
+    cacheTtlSeconds: Number(doc.cacheTtlSeconds || 0) || 0,
+    updatedAt: doc.updatedAt,
+    data,
+  };
+}
+
+module.exports = {
+  normalizeSlugBase,
+  generateUniqueSlugFromTitle,
+  parseJsonOrThrow,
+  clearJsonConfigCache,
+  clearAllJsonConfigCache,
+  listJsonConfigs,
+  getJsonConfigById,
+  createJsonConfig,
+  updateJsonConfig,
+  regenerateJsonConfigSlug,
+  deleteJsonConfig,
+  getJsonConfig: getJsonConfigValueBySlug,
+  getJsonConfigValueBySlug,
+  getJsonConfigPublicPayload,
+};