create-snapify-app 0.0.0-stage → 1.1.1

package/template/server/cms/revisions.ts

@@ -0,0 +1,99 @@
+/**
+ * Snapify
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Contact : contact@novalabs.tn · +216 24 734 647
+ * Tous droits réservés. Toute reproduction, modification ou diffusion sans autorisation écrite est interdite.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import crypto from 'crypto';
+import { and, desc, eq, inArray } from 'drizzle-orm';
+import type { BlogPost, CmsPage, ContentRevision } from './types';
+import { db, type Tx } from '../db/client';
+import { revisions } from '../db/schema';
+
+const MAX_REVISIONS_PER_ENTITY = 50;
+
+const toRevision = (r: typeof revisions.$inferSelect): ContentRevision => ({
+  id: r.id,
+  entityType: r.entityType,
+  entityId: r.entityId,
+  label: r.label,
+  snapshot: r.snapshot,
+  createdAt: r.createdAt.toISOString(),
+  ...(r.authorEmail ? { authorEmail: r.authorEmail } : {}),
+});
+
+export async function saveRevision(params: {
+  entityType: 'page' | 'post';
+  entityId: string;
+  label: string;
+  snapshot: CmsPage | BlogPost;
+  authorEmail?: string;
+}): Promise<ContentRevision> {
+  const [row] = await db
+    .insert(revisions)
+    .values({
+      id: crypto.randomUUID(),
+      entityType: params.entityType,
+      entityId: params.entityId,
+      label: params.label,
+      snapshot: structuredClone(params.snapshot),
+      authorEmail: params.authorEmail ?? null,
+    })
+    .returning();
+
+  const stale = await db
+    .select({ id: revisions.id })
+    .from(revisions)
+    .where(and(eq(revisions.entityType, params.entityType), eq(revisions.entityId, params.entityId)))
+    .orderBy(desc(revisions.createdAt))
+    .offset(MAX_REVISIONS_PER_ENTITY);
+  if (stale.length) await db.delete(revisions).where(inArray(revisions.id, stale.map((s) => s.id)));
+
+  return toRevision(row);
+}
+
+export async function listRevisions(entityType: 'page' | 'post', entityId: string): Promise<ContentRevision[]> {
+  const rows = await db
+    .select()
+    .from(revisions)
+    .where(and(eq(revisions.entityType, entityType), eq(revisions.entityId, entityId)))
+    .orderBy(desc(revisions.createdAt));
+  return rows.map(toRevision);
+}
+
+export async function getRevision(id: string): Promise<ContentRevision | null> {
+  if (!/^[0-9a-f-]{36}$/i.test(id)) return null;
+  const [row] = await db.select().from(revisions).where(eq(revisions.id, id));
+  return row ? toRevision(row) : null;
+}
+
+/** Import unique des révisions stockées en fichiers JSON avant le passage à PostgreSQL. */
+export async function importLegacyRevisions(tx: Tx, dir: string): Promise<void> {
+  let files: string[];
+  try {
+    files = (await fs.readdir(dir)).filter((f) => f.endsWith('.json'));
+  } catch {
+    return;
+  }
+  for (const f of files) {
+    try {
+      const rev = JSON.parse(await fs.readFile(path.join(dir, f), 'utf-8')) as ContentRevision;
+      await tx
+        .insert(revisions)
+        .values({
+          id: rev.id,
+          entityType: rev.entityType,
+          entityId: rev.entityId,
+          label: rev.label,
+          snapshot: rev.snapshot,
+          authorEmail: rev.authorEmail ?? null,
+          createdAt: new Date(rev.createdAt),
+        })
+        .onConflictDoNothing();
+    } catch (e) {
+      console.warn(`[cms] révision ignorée (${f})`, e);
+    }
+  }
+}

package/template/server/cms/scheduler.ts

@@ -0,0 +1,78 @@
+/**
+ * Snapify
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Contact : contact@novalabs.tn · +216 24 734 647
+ * Tous droits réservés. Toute reproduction, modification ou diffusion sans autorisation écrite est interdite.
+ */
+import type { CmsPage, CmsSnapshot, PageContentSource } from './types';
+import { createDefaultMenus, createDefaultSeoGlobal, createDefaultSystemSettings, createDefaultWidgetAreas, withDefaults } from './defaults';
+import { createDefaultRoles, isPermission, SUPERADMIN_ROLE } from './permissions';
+import { migrateContentToBlocks } from './contentMigration';
+
+/** Publie les pages/articles planifiés dont la date est passée. */
+export function applyScheduledPublishing(snapshot: CmsSnapshot): boolean {
+  const now = Date.now();
+  let changed = false;
+
+  for (const page of snapshot.pages) {
+    if (page.status === 'scheduled' && page.scheduledAt) {
+      if (new Date(page.scheduledAt).getTime() <= now) {
+        page.status = 'published';
+        page.publishedAt = new Date().toISOString();
+        changed = true;
+      }
+    }
+  }
+
+  for (const post of snapshot.posts) {
+    if (post.status === 'scheduled' && post.scheduledAt) {
+      if (new Date(post.scheduledAt).getTime() <= now) {
+        post.status = 'published';
+        post.publishedAt = new Date().toISOString();
+        changed = true;
+      }
+    } else if (post.status === 'draft' && post.publishedAt) {
+      const pub = new Date(post.publishedAt).getTime();
+      if (pub <= now && pub > 0) {
+        post.status = 'published';
+        changed = true;
+      }
+    }
+  }
+
+  return changed;
+}
+
+export function migrateSnapshot(snapshot: CmsSnapshot): void {
+  if (!snapshot.settings.seo) snapshot.settings.seo = createDefaultSeoGlobal();
+  if (!snapshot.floatingButtons) snapshot.floatingButtons = [];
+  snapshot.system = withDefaults(createDefaultSystemSettings(), snapshot.system);
+  if (!Array.isArray(snapshot.roles) || !snapshot.roles.length) snapshot.roles = createDefaultRoles();
+  const superRole = createDefaultRoles()[0];
+  snapshot.roles = [superRole, ...snapshot.roles.filter((r) => r.id !== SUPERADMIN_ROLE)];
+  for (const r of snapshot.roles) r.permissions = r.permissions.filter(isPermission);
+  for (const u of snapshot.users) {
+    u.status ??= 'active';
+    if (!snapshot.roles.some((r) => r.id === u.role)) u.role = 'viewer';
+  }
+  for (const page of snapshot.pages) {
+    const p = page as CmsPage & { contentSource?: PageContentSource };
+    if (!p.contentSource) {
+      p.contentSource =
+        page.path === '/mentions-legales/' ||
+        page.path === '/politique-de-confidentialite/' ||
+        page.path === '/cookies/'
+          ? 'cms'
+          : 'react';
+    }
+  }
+  migrateContentToBlocks(snapshot);
+  if (!Array.isArray(snapshot.widgetAreas) || !snapshot.widgetAreas.length) {
+    snapshot.widgetAreas = createDefaultWidgetAreas();
+  }
+  if (!Array.isArray(snapshot.blockPatterns)) snapshot.blockPatterns = [];
+  const defaultMenus = createDefaultMenus();
+  for (const dm of defaultMenus) {
+    if (!snapshot.menus.some((m) => m.id === dm.id)) snapshot.menus.push(dm);
+  }
+}

package/template/server/cms/seed.ts

@@ -0,0 +1,72 @@
+/**
+ * Snapify
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Contact : contact@novalabs.tn · +216 24 734 647
+ * Tous droits réservés. Toute reproduction, modification ou diffusion sans autorisation écrite est interdite.
+ */
+import type { CmsPage, CmsSnapshot } from './types';
+import { cmsNow, defaultSeoForPath } from './defaults';
+import { ensureDefaultAdmin } from './auth';
+
+const CORE_PATHS: { path: string; title: string; template: CmsPage['template'] }[] = [
+  { path: '/', title: 'Accueil', template: 'landing' },
+  { path: '/expertises/', title: 'Lorem', template: 'default' },
+  { path: '/secteurs/', title: 'Ipsum', template: 'default' },
+  { path: '/realisations/', title: 'Réalisations', template: 'default' },
+  { path: '/notre-approche/', title: 'Notre approche', template: 'default' },
+  { path: '/contact/', title: 'Contact', template: 'default' },
+  { path: '/mentions-legales/', title: 'Mentions légales', template: 'legal' },
+  { path: '/politique-de-confidentialite/', title: 'Politique de confidentialité', template: 'legal' },
+  { path: '/cookies/', title: 'Cookies', template: 'legal' },
+];
+
+export async function ensureSeeded(snapshot: CmsSnapshot): Promise<void> {
+  snapshot.users = await ensureDefaultAdmin(snapshot.users);
+
+  if (snapshot.pages.length === 0) {
+    const t = cmsNow();
+    snapshot.pages = CORE_PATHS.map((p, i) => ({
+      id: `page-${i + 1}`,
+      path: p.path,
+      title: p.title,
+      status: 'published' as const,
+      publishedAt: t,
+      contentSource: p.template === 'legal' ? ('cms' as const) : ('react' as const),
+      template: p.template,
+      blocks:
+        p.path === '/'
+          ? [
+              {
+                id: 'hero-home',
+                type: 'hero' as const,
+                data: {
+                  title: 'Lorem ipsum dolor sit amet',
+                  subtitle: 'Audit, travaux, financement CEE et suivi des économies — partout en France.',
+                  ctaLabel: 'Lorem ipsum dolor',
+                  ctaPath: '/contact/',
+                  backgroundStyle: 'gradient',
+                },
+              },
+            ]
+          : [
+              {
+                id: `intro-${i}`,
+                type: 'richText' as const,
+                data: {
+                  html: `<p>Contenu géré depuis le backoffice pour <strong>${p.title}</strong>. Le front React actuel reste la vue par défaut tant que la page n'est pas entièrement reconstruite en blocs.</p>`,
+                },
+              },
+            ],
+      seo: defaultSeoForPath(p.path, p.title),
+      createdAt: t,
+      updatedAt: t,
+    }));
+  }
+
+  if (snapshot.redirects.length === 0) {
+    snapshot.redirects = [
+      { from: '/contactez-nous/', to: '/contact/', permanent: true },
+      { from: '/nos-solutions/', to: '/expertises/', permanent: true },
+    ];
+  }
+}

package/template/server/cms/seoAnalyzer.ts

@@ -0,0 +1,213 @@
+/**
+ * Snapify
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Contact : contact@novalabs.tn · +216 24 734 647
+ * Tous droits réservés. Toute reproduction, modification ou diffusion sans autorisation écrite est interdite.
+ */
+import { blockToHtml } from './blocks';
+import type { BlogPost, CmsBlock, CmsPage, SeoMeta } from './types';
+
+/* Module pur : partagé entre le serveur et l'éditeur (analyse en direct). */
+
+export type CheckStatus = 'pass' | 'warn' | 'fail';
+export interface SeoCheck {
+  id: string;
+  group: 'seo' | 'readability';
+  label: string;
+  status: CheckStatus;
+  hint?: string;
+}
+export interface SeoAnalysis {
+  score: number;
+  status: 'bad' | 'ok' | 'good';
+  readabilityScore: number;
+  readabilityStatus: 'bad' | 'ok' | 'good';
+  checks: SeoCheck[];
+  stats: { words: number; keyphraseCount: number; density: number; internalLinks: number; externalLinks: number; images: number };
+}
+
+interface ContentModel {
+  html: string;
+  text: string;
+  headings: string[];
+  paragraphs: string[];
+  images: { alt: string }[];
+  links: string[];
+}
+
+const stripTags = (html: string) =>
+  html
+    .replace(/<br\s*\/?>/gi, ' ')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&amp;/g, '&')
+    .replace(/&[a-z]+;/gi, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+const normalize = (s: string) =>
+  s
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/[’']/g, ' ');
+
+const words = (s: string) => s.split(/\s+/).filter((w) => /[\p{L}\p{N}]/u.test(w));
+
+function blocksToContent(blocks: CmsBlock[], extraText = ''): ContentModel {
+  const htmlParts: string[] = [];
+  const images: { alt: string }[] = [];
+  for (const b of blocks) {
+    const { html, alts } = blockToHtml(b);
+    htmlParts.push(html);
+    for (const alt of alts) images.push({ alt });
+  }
+  const html = (extraText ? `<p>${extraText}</p>` : '') + htmlParts.join('\n');
+  for (const m of html.matchAll(/<img[^>]*?(?:alt="([^"]*)")?[^>]*>/gi)) images.push({ alt: m[1] || '' });
+  return {
+    html,
+    text: stripTags(html),
+    headings: [...html.matchAll(/<h[2-4][^>]*>([\s\S]*?)<\/h[2-4]>/gi)].map((m) => stripTags(m[1])),
+    paragraphs: [...html.matchAll(/<p[^>]*>([\s\S]*?)<\/p>/gi)].map((m) => stripTags(m[1])).filter(Boolean),
+    images,
+    links: [...html.matchAll(/<a[^>]*href="([^"]+)"/gi)].map((m) => m[1]),
+  };
+}
+
+function countOccurrences(haystack: string, needle: string): number {
+  if (!needle) return 0;
+  const h = ` ${normalize(haystack).replace(/[^\p{L}\p{N}]+/gu, ' ')} `;
+  const n = ` ${normalize(needle).replace(/[^\p{L}\p{N}]+/gu, ' ').trim()} `;
+  if (n.trim() === '') return 0;
+  let count = 0;
+  let idx = h.indexOf(n);
+  while (idx !== -1) {
+    count++;
+    idx = h.indexOf(n, idx + n.length - 1);
+  }
+  return count;
+}
+
+const has = (text: string, kp: string) => countOccurrences(text, kp) > 0;
+
+const TRANSITIONS = [
+  'ainsi', 'donc', 'cependant', 'en effet', 'par consequent', 'de plus', 'enfin', 'd abord', 'ensuite', 'toutefois',
+  'neanmoins', 'en outre', 'par exemple', 'car', 'puisque', 'alors', 'en revanche', 'finalement', 'notamment', 'pourtant',
+  'c est pourquoi', 'en resume', 'premierement', 'egalement', 'afin de',
+];
+
+function scoreOf(checks: SeoCheck[]): number {
+  if (!checks.length) return 0;
+  const pts = checks.reduce((s, c) => s + (c.status === 'pass' ? 1 : c.status === 'warn' ? 0.5 : 0), 0);
+  return Math.round((pts / checks.length) * 100);
+}
+const statusOf = (score: number) => (score >= 75 ? 'good' : score >= 50 ? 'ok' : 'bad') as SeoAnalysis['status'];
+
+export function analyzeContent(seo: SeoMeta, blocks: CmsBlock[], opts: { kind: 'page' | 'post'; extraText?: string; siteHost?: string }): SeoAnalysis {
+  const c = blocksToContent(blocks, opts.extraText);
+  const kp = seo.focusKeyphrase.trim();
+  const wc = words(c.text).length;
+  const kpCount = countOccurrences(c.text, kp);
+  const kpWords = kp ? words(kp).length : 1;
+  const density = wc ? (kpCount * kpWords * 100) / wc : 0;
+  const internal = c.links.filter((l) => l.startsWith('/') || (opts.siteHost && l.includes(opts.siteHost))).length;
+  const external = c.links.length - internal;
+  const checks: SeoCheck[] = [];
+  const add = (id: string, group: SeoCheck['group'], label: string, status: CheckStatus, hint?: string) =>
+    checks.push({ id, group, label, status, hint });
+
+  /* --- SEO --- */
+  if (!kp) {
+    add('kp', 'seo', 'Expression clé principale', 'fail', 'Définissez l’expression sur laquelle cette page doit se positionner.');
+  } else {
+    const inTitle = has(seo.seoTitle, kp);
+    const atStart = normalize(seo.seoTitle).startsWith(normalize(kp));
+    add('kp-title', 'seo', 'Expression clé dans le titre SEO', inTitle ? (atStart ? 'pass' : 'warn') : 'fail',
+      inTitle ? (atStart ? undefined : 'Idéalement placée en début de titre.') : `Ajoutez « ${kp} » au titre SEO.`);
+    add('kp-desc', 'seo', 'Expression clé dans la meta description', has(seo.metaDescription, kp) ? 'pass' : 'fail',
+      has(seo.metaDescription, kp) ? undefined : 'Google met en gras les termes recherchés dans la description.');
+    const slugHit = words(normalize(kp)).every((w) => normalize(seo.slug).includes(w.replace(/[^a-z0-9]/g, '')));
+    add('kp-slug', 'seo', 'Expression clé dans l’URL', slugHit ? 'pass' : 'warn', slugHit ? undefined : 'Intégrez les mots-clés dans le slug.');
+    const intro = c.paragraphs.slice(0, 2).join(' ') || c.text.slice(0, 400);
+    add('kp-intro', 'seo', 'Expression clé dans l’introduction', has(intro, kp) ? 'pass' : 'fail',
+      has(intro, kp) ? undefined : 'Mentionnez-la dans le premier paragraphe.');
+    if (wc >= 100) {
+      const ok = density >= 0.5 && density <= 3;
+      add('kp-density', 'seo', `Densité de l’expression clé (${density.toFixed(1)} %)`, ok ? 'pass' : density > 3 ? 'fail' : 'warn',
+        ok ? `${kpCount} occurrence(s).` : density > 3 ? 'Sur-optimisation : réduisez les répétitions.' : 'Viser entre 0,5 % et 3 %.');
+    }
+    const headHit = c.headings.some((h) => has(h, kp));
+    add('kp-headings', 'seo', 'Expression clé dans un sous-titre', c.headings.length ? (headHit ? 'pass' : 'warn') : 'warn',
+      c.headings.length ? (headHit ? undefined : 'Reprenez-la dans un H2 ou H3.') : 'Ajoutez des sous-titres (H2/H3).');
+    if (c.images.length) {
+      const altHit = c.images.some((i) => has(i.alt, kp));
+      add('kp-alt', 'seo', 'Expression clé dans un texte alternatif d’image', altHit ? 'pass' : 'warn');
+    }
+  }
+
+  const tl = seo.seoTitle.trim().length;
+  add('title-len', 'seo', `Longueur du titre SEO (${tl} car.)`, tl >= 30 && tl <= 60 ? 'pass' : tl === 0 ? 'fail' : 'warn',
+    tl < 30 ? 'Trop court : 30 à 60 caractères.' : tl > 60 ? 'Sera tronqué dans Google au-delà de ~60 caractères.' : undefined);
+  const dl = seo.metaDescription.trim().length;
+  add('desc-len', 'seo', `Longueur de la meta description (${dl} car.)`, dl >= 120 && dl <= 160 ? 'pass' : dl === 0 ? 'fail' : 'warn',
+    dl < 120 ? 'Trop courte : 120 à 160 caractères.' : dl > 160 ? 'Sera tronquée au-delà de 160 caractères.' : undefined);
+  const minWords = opts.kind === 'post' ? 600 : 300;
+  add('length', 'seo', `Longueur du contenu (${wc} mots)`, wc >= minWords ? 'pass' : wc >= minWords / 2 ? 'warn' : 'fail',
+    wc >= minWords ? undefined : `Visez au moins ${minWords} mots.`);
+  add('internal', 'seo', 'Liens internes', internal > 0 ? 'pass' : 'warn', internal ? undefined : 'Ajoutez des liens vers d’autres pages du site.');
+  add('external', 'seo', 'Liens sortants', external > 0 ? 'pass' : 'warn', external ? undefined : 'Citez une source externe de référence.');
+  const missingAlt = c.images.filter((i) => !i.alt.trim()).length;
+  add('alts', 'seo', 'Textes alternatifs des images', !c.images.length ? 'warn' : missingAlt ? 'fail' : 'pass',
+    !c.images.length ? 'Aucune image : un visuel améliore l’engagement.' : missingAlt ? `${missingAlt} image(s) sans texte alternatif.` : undefined);
+  add('og', 'seo', 'Image de partage social', seo.ogImage ? 'pass' : 'warn', seo.ogImage ? undefined : 'Définissez une image Open Graph (1200×630).');
+  if (seo.noindex) add('noindex', 'seo', 'Indexation désactivée', 'fail', 'Cette page n’apparaîtra pas dans Google (noindex).');
+
+  /* --- Lisibilité --- */
+  const sentences = c.text.split(/(?<=[.!?…])\s+/).map((s) => words(s).length).filter((n) => n > 0);
+  if (sentences.length >= 3) {
+    const longShare = (sentences.filter((n) => n > 20).length / sentences.length) * 100;
+    add('sentences', 'readability', `Phrases longues (${Math.round(longShare)} %)`, longShare <= 25 ? 'pass' : longShare <= 35 ? 'warn' : 'fail',
+      longShare <= 25 ? undefined : 'Moins de 25 % des phrases devraient dépasser 20 mots.');
+  }
+  const longParas = c.paragraphs.filter((p) => words(p).length > 150).length;
+  if (c.paragraphs.length) {
+    add('paragraphs', 'readability', 'Longueur des paragraphes', longParas ? 'warn' : 'pass', longParas ? `${longParas} paragraphe(s) de plus de 150 mots.` : undefined);
+  }
+  if (wc > 300) {
+    const perHeading = wc / (c.headings.length + 1);
+    add('subheadings', 'readability', 'Répartition des sous-titres', perHeading <= 300 ? 'pass' : 'warn',
+      perHeading <= 300 ? undefined : 'Ajoutez un sous-titre toutes les 300 mots environ.');
+  }
+  if (sentences.length >= 5) {
+    const norm = normalize(c.text);
+    const sentencesText = norm.split(/[.!?…]+/);
+    const withTransition = sentencesText.filter((s) => TRANSITIONS.some((t) => ` ${s} `.includes(` ${t} `))).length;
+    const share = (withTransition / sentencesText.length) * 100;
+    add('transitions', 'readability', `Mots de liaison (${Math.round(share)} %)`, share >= 20 ? 'pass' : 'warn',
+      share >= 20 ? undefined : 'Utilisez davantage de connecteurs (ainsi, en effet, par exemple…).');
+  }
+  if (!checks.some((c) => c.group === 'readability')) {
+    add('readability-min', 'readability', 'Texte suffisant pour évaluer la lisibilité', 'warn', 'Rédigez davantage de contenu.');
+  }
+
+  const seoChecks = checks.filter((x) => x.group === 'seo');
+  const readChecks = checks.filter((x) => x.group === 'readability');
+  const score = scoreOf(seoChecks);
+  const readabilityScore = scoreOf(readChecks);
+  return {
+    score,
+    status: statusOf(score),
+    readabilityScore,
+    readabilityStatus: statusOf(readabilityScore),
+    checks,
+    stats: { words: wc, keyphraseCount: kpCount, density: Math.round(density * 10) / 10, internalLinks: internal, externalLinks: external, images: c.images.length },
+  };
+}
+
+export function analyzePageSeo(page: CmsPage): SeoAnalysis {
+  return analyzeContent(page.seo, page.blocks, { kind: 'page' });
+}
+
+export function analyzePostSeo(post: BlogPost): SeoAnalysis {
+  return analyzeContent(post.seo, post.blocks, { kind: 'post', extraText: post.excerpt });
+}

package/template/server/cms/store.ts

@@ -0,0 +1,122 @@
+/**
+ * Snapify
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Contact : contact@novalabs.tn · +216 24 734 647
+ * Tous droits réservés. Toute reproduction, modification ou diffusion sans autorisation écrite est interdite.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import type { CmsSnapshot } from './types';
+import { createEmptySnapshot } from './defaults';
+import { ensureSeeded } from './seed';
+import { applyScheduledPublishing, migrateSnapshot } from './scheduler';
+import { db, runMigrations } from '../db/client';
+import { loadFromDatabase, persistSnapshot } from '../db/repository';
+import { importLegacyAnalytics } from './analyticsStore';
+import { importLegacyRevisions } from './revisions';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DATA_DIR = path.resolve(__dirname, '../../data/cms');
+const LEGACY_SNAPSHOT = path.join(DATA_DIR, 'snapshot.json');
+
+/*
+ * PostgreSQL est la source de vérité. L'état est gardé en mémoire (processus unique sous PM2)
+ * et chaque mutation est écrite en transaction avant de remplacer le cache : une écriture
+ * en échec laisse le cache intact.
+ */
+let cache: CmsSnapshot | null = null;
+let loading: Promise<CmsSnapshot> | null = null;
+let mutationQueue: Promise<unknown> = Promise.resolve();
+let lastScheduleCheck = 0;
+
+async function readLegacySnapshot(): Promise<CmsSnapshot | null> {
+  try {
+    return JSON.parse(await fs.readFile(LEGACY_SNAPSHOT, 'utf-8')) as CmsSnapshot;
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException).code === 'ENOENT') return null;
+    throw e;
+  }
+}
+
+async function initialLoad(): Promise<CmsSnapshot> {
+  await runMigrations();
+
+  const stored = await loadFromDatabase();
+  if (stored) {
+    const migrated = structuredClone(stored);
+    migrateSnapshot(migrated);
+    await db.transaction((tx) => persistSnapshot(tx, stored, migrated));
+    return migrated;
+  }
+
+  // Base vide : import de l'ancien fichier JSON s'il existe, sinon contenu initial.
+  const legacy = await readLegacySnapshot();
+  const snapshot = legacy ?? createEmptySnapshot();
+  if (!legacy) await ensureSeeded(snapshot);
+  migrateSnapshot(snapshot);
+  const legacyEvents = snapshot.analyticsEvents;
+  delete snapshot.analyticsEvents;
+
+  await db.transaction(async (tx) => {
+    await persistSnapshot(tx, null, snapshot);
+    await importLegacyRevisions(tx, path.join(DATA_DIR, 'revisions'));
+    await importLegacyAnalytics(tx, path.join(DATA_DIR, 'analytics.jsonl'), legacyEvents);
+  });
+
+  if (legacy) {
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    await fs.rename(LEGACY_SNAPSHOT, `${LEGACY_SNAPSHOT}.imported-${stamp}`);
+    console.log('[cms] snapshot.json importé dans PostgreSQL (copie conservée)');
+  }
+  return snapshot;
+}
+
+async function ensureLoaded(): Promise<CmsSnapshot> {
+  if (!cache) {
+    loading ??= initialLoad().catch((e) => {
+      loading = null;
+      throw e;
+    });
+    cache = await loading;
+  }
+  return cache;
+}
+
+export async function loadSnapshot(): Promise<CmsSnapshot> {
+  const snapshot = await ensureLoaded();
+  if (Date.now() - lastScheduleCheck > 60_000) {
+    lastScheduleCheck = Date.now();
+    if (applyScheduledPublishing(structuredClone(snapshot))) {
+      return updateSnapshot((s) => {
+        applyScheduledPublishing(s);
+      });
+    }
+  }
+  return snapshot;
+}
+
+/** Mutations sérialisées : chaque mutateur part de la dernière version persistée. */
+export function updateSnapshot(mutator: (s: CmsSnapshot) => void): Promise<CmsSnapshot> {
+  const run = mutationQueue.then(async () => {
+    const current = await ensureLoaded();
+    const next = structuredClone(current);
+    mutator(next);
+    await db.transaction((tx) => persistSnapshot(tx, current, next));
+    cache = next;
+    return next;
+  });
+  mutationQueue = run.catch(() => undefined);
+  return run;
+}
+
+export function getDataPaths() {
+  return { DATA_DIR, UPLOADS_DIR: path.resolve(__dirname, '../../public/uploads') };
+}
+
+/** Vide le cache mémoire et recharge depuis PostgreSQL (après restore démo). */
+export async function reloadSnapshotFromDb(): Promise<CmsSnapshot> {
+  cache = null;
+  loading = null;
+  return loadSnapshot();
+}