create-snapify-app 0.0.0-stage → 1.1.1

package/template/server/demo/cmsReset.ts

@@ -0,0 +1,196 @@
+/**
+ * Snapify — restauration périodique des tables CMS (démo /demo)
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ * Ne touche pas marketplace / community / platform.
+ */
+import { execFile } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { promisify } from 'util';
+import { hashPassword } from '../cms/auth';
+import { reloadSnapshotFromDb, updateSnapshot } from '../cms/store';
+
+const execFileAsync = promisify(execFile);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '../..');
+const BASELINE = path.join(ROOT, 'backups/db/demo-cms-baseline.dump');
+const META = path.join(ROOT, 'backups/db/demo-cms-meta.json');
+
+/** Tables CMS uniquement (hors platform / forum / marketplace). */
+export const CMS_TABLES = [
+  'site_settings',
+  'pages',
+  'posts',
+  'revisions',
+  'menus',
+  'redirects',
+  'forms',
+  'form_submissions',
+  'newsletter_subscribers',
+  'media',
+  'admin_users',
+  'admin_sessions',
+  'audit_log',
+  'mail_log',
+  'auth_tokens',
+  'modules',
+  'module_storage',
+  'module_records',
+  'analytics_events',
+] as const;
+
+function pgEnv() {
+  const url = process.env.DATABASE_URL || '';
+  // postgres://user:pass@host:port/db
+  const m = url.match(/^postgres(?:ql)?:\/\/([^:]+):([^@]+)@([^:\/]+):?(\d+)?\/(.+)$/);
+  if (!m) throw new Error('DATABASE_URL invalide pour le reset démo');
+  return {
+    user: decodeURIComponent(m[1]),
+    password: decodeURIComponent(m[2]),
+    host: m[3],
+    port: m[4] || '5432',
+    database: m[5].split('?')[0],
+  };
+}
+
+export function demoCredentials() {
+  return {
+    email: (process.env.DEMO_ADMIN_EMAIL || process.env.ADMIN_EMAIL || 'admin@snapify.fr').toLowerCase(),
+    password: process.env.DEMO_ADMIN_PASSWORD || 'SnapifyDemo1',
+  };
+}
+
+export async function createCmsBaseline(): Promise<string> {
+  await fs.mkdir(path.dirname(BASELINE), { recursive: true });
+  const cfg = pgEnv();
+  const container = process.env.POSTGRES_CONTAINER || 'snapify-postgres';
+  const tableArgs = CMS_TABLES.flatMap((t) => ['-t', t]);
+  const { stdout } = await execFileAsync(
+    'docker',
+    ['exec', '-e', `PGPASSWORD=${cfg.password}`, container, 'pg_dump', '-U', cfg.user, '-d', cfg.database, '-Fc', ...tableArgs],
+    { encoding: 'buffer', maxBuffer: 128 * 1024 * 1024 }
+  );
+  await fs.writeFile(BASELINE, stdout);
+  await fs.writeFile(
+    META,
+    JSON.stringify({ createdAt: new Date().toISOString(), tables: CMS_TABLES, bytes: stdout.length }, null, 2)
+  );
+  console.log(`[demo] baseline CMS : ${BASELINE} (${stdout.length} octets)`);
+  return BASELINE;
+}
+
+export async function ensureDemoAdminPassword() {
+  const { email, password } = demoCredentials();
+  const { hash, salt } = hashPassword(password);
+  const now = new Date().toISOString();
+  await updateSnapshot((s) => {
+    const existing = s.users.find((u) => u.email.toLowerCase() === email);
+    if (existing) {
+      existing.passwordHash = hash;
+      existing.salt = salt;
+      existing.status = 'active';
+      existing.role = 'superadmin';
+      existing.mustChangePassword = false;
+      existing.totpEnabled = false;
+      existing.passwordChangedAt = now;
+    } else if (s.users[0]) {
+      // Aligne le premier admin sur les credentials démo publics
+      s.users[0].email = email;
+      s.users[0].passwordHash = hash;
+      s.users[0].salt = salt;
+      s.users[0].status = 'active';
+      s.users[0].role = 'superadmin';
+      s.users[0].mustChangePassword = false;
+      s.users[0].totpEnabled = false;
+      s.users[0].name = s.users[0].name || 'Démo Snapify';
+      s.users[0].passwordChangedAt = now;
+    } else {
+      s.users.push({
+        id: 'demo-admin',
+        email,
+        passwordHash: hash,
+        salt,
+        role: 'superadmin',
+        name: 'Démo Snapify',
+        status: 'active',
+        mustChangePassword: false,
+        totpEnabled: false,
+        recoveryCodes: [],
+        passwordChangedAt: now,
+        createdAt: now,
+      });
+    }
+  });
+}
+
+export async function restoreCmsBaseline(): Promise<void> {
+  try {
+    await fs.access(BASELINE);
+  } catch {
+    console.warn('[demo] pas de baseline — création depuis l’état actuel');
+    await createCmsBaseline();
+    await ensureDemoAdminPassword();
+    return;
+  }
+
+  const cfg = pgEnv();
+  const container = process.env.POSTGRES_CONTAINER || 'snapify-postgres';
+  const dump = await fs.readFile(BASELINE);
+
+  // Truncate CMS tables (cascade) then restore
+  const truncate = `TRUNCATE ${CMS_TABLES.map((t) => `"${t}"`).join(', ')} RESTART IDENTITY CASCADE;`;
+  await execFileAsync(
+    'docker',
+    ['exec', '-e', `PGPASSWORD=${cfg.password}`, container, 'psql', '-U', cfg.user, '-d', cfg.database, '-v', 'ON_ERROR_STOP=1', '-c', truncate],
+    { maxBuffer: 2 * 1024 * 1024 }
+  );
+
+  await new Promise<void>((resolve, reject) => {
+    const child = execFile(
+      'docker',
+      [
+        'exec',
+        '-i',
+        '-e',
+        `PGPASSWORD=${cfg.password}`,
+        container,
+        'pg_restore',
+        '-U',
+        cfg.user,
+        '-d',
+        cfg.database,
+        '--data-only',
+        '--no-owner',
+        '--disable-triggers',
+      ],
+      { maxBuffer: 128 * 1024 * 1024 },
+      (err) => (err ? reject(err) : resolve())
+    );
+    child.stdin?.write(dump);
+    child.stdin?.end();
+  });
+
+  await reloadSnapshotFromDb();
+  await ensureDemoAdminPassword();
+  console.log('[demo] tables CMS restaurées depuis baseline');
+}
+
+export async function startDemoResetScheduler() {
+  if (process.env.DEMO_CMS_RESET === 'false') {
+    console.log('[demo] reset CMS désactivé (DEMO_CMS_RESET=false)');
+    return;
+  }
+  await ensureDemoAdminPassword();
+  try {
+    await fs.access(BASELINE);
+  } catch {
+    await createCmsBaseline();
+  }
+
+  const hours = Math.max(1, Number(process.env.DEMO_CMS_RESET_HOURS) || 24);
+  const tick = () => restoreCmsBaseline().catch((e) => console.error('[demo] restore impossible', e));
+  const timer = setInterval(tick, hours * 3600 * 1000);
+  timer.unref();
+  console.log(`[demo] reset CMS programmé toutes les ${hours} h · identifiants ${demoCredentials().email}`);
+}

package/template/server/developers/sdk.ts

@@ -0,0 +1,85 @@
+/**
+ * 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.
+ */
+/**
+ * Téléchargement du kit développeur (`npm run sdk:pack` → releases/sdk/) :
+ *   GET /api/developers/sdk          versions, tailles et empreintes SHA-256 (portail développeurs)
+ *   GET /sdk/<fichier>               paquet npm, projets de départ, sommes de contrôle (developers.snapify.tn)
+ *   GET /sdk/snapify-sdk-latest.tgz  redirection vers la dernière version
+ */
+import express, { type Request, type Response, type NextFunction } from 'express';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { resolveAppHost } from '../platform/host';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const RELEASES = path.resolve(__dirname, '../../releases/sdk');
+
+const VERSION = String.raw`\d+\.\d+\.\d+(?:-[0-9a-z.]+)?`;
+const FILES: { pattern: RegExp; type: string; attachment: boolean }[] = [
+  { pattern: new RegExp(`^snapify-sdk-${VERSION}\\.tgz$`), type: 'application/gzip', attachment: true },
+  { pattern: new RegExp(`^snapify-starter-${VERSION}\\.zip$`), type: 'application/zip', attachment: true },
+  { pattern: new RegExp(`^SHA256SUMS-${VERSION}\\.txt$`), type: 'text/plain; charset=utf-8', attachment: false },
+];
+
+interface SdkIndex {
+  latest?: string;
+  releases: { version: string; files: { name: string }[] }[];
+}
+
+let cached: { mtime: number; index: SdkIndex } | null = null;
+
+async function loadIndex(): Promise<SdkIndex | null> {
+  const file = path.join(RELEASES, 'index.json');
+  const stat = await fs.stat(file).catch(() => null);
+  if (!stat) return null;
+  if (!cached || cached.mtime !== stat.mtimeMs) cached = { mtime: stat.mtimeMs, index: JSON.parse(await fs.readFile(file, 'utf8')) as SdkIndex };
+  return cached.index;
+}
+
+export function createSdkDownloadsRouter() {
+  const r = express.Router();
+
+  r.get('/api/developers/sdk', async (_req, res, next) => {
+    try {
+      const index = await loadIndex();
+      if (!index?.latest) return res.status(404).json({ error: 'Kit développeur non publié' });
+      res.setHeader('Cache-Control', 'public, max-age=300');
+      res.json(index);
+    } catch (e) {
+      next(e);
+    }
+  });
+
+  r.get('/sdk/:file', async (req: Request, res: Response, next: NextFunction) => {
+    if (resolveAppHost(req) !== 'developers') return next();
+    try {
+      const name = req.params.file;
+      if (name === 'snapify-sdk-latest.tgz') {
+        const latest = (await loadIndex())?.latest;
+        if (!latest) return res.status(404).type('text').send('Kit développeur non publié');
+        res.setHeader('Cache-Control', 'no-cache');
+        return res.redirect(302, `/sdk/snapify-sdk-${latest}.tgz`);
+      }
+      const kind = FILES.find((f) => f.pattern.test(name));
+      const index = await loadIndex();
+      const published = index?.releases.some((rel) => rel.files.some((f) => f.name === name) || `SHA256SUMS-${rel.version}.txt` === name);
+      if (!kind || !published) return res.status(404).type('text').send('Fichier introuvable');
+      res.setHeader('Content-Type', kind.type);
+      res.setHeader('X-Content-Type-Options', 'nosniff');
+      res.setHeader('Cache-Control', 'public, max-age=86400');
+      if (kind.attachment) res.setHeader('Content-Disposition', `attachment; filename="${name}"`);
+      res.sendFile(path.join(RELEASES, name), (err) => {
+        if (err && !res.headersSent) res.status(404).type('text').send('Fichier introuvable');
+      });
+    } catch (e) {
+      next(e);
+    }
+  });
+
+  return r;
+}

package/template/server/geoip.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 geoip from 'geoip-lite';
+
+export function resolveGeoFromIp(ip: string): { country?: string; city?: string } {
+  const clean = ip.replace(/^::ffff:/, '');
+  if (!clean || clean === '127.0.0.1' || clean === '::1') return {};
+  const lookup = geoip.lookup(clean);
+  if (!lookup) return {};
+  return { country: lookup.country, city: lookup.city };
+}

package/template/server/http.ts

@@ -0,0 +1,53 @@
+/**
+ * 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 { Router, type Request, type Response, type NextFunction, type RequestHandler } from 'express';
+
+export class HttpError extends Error {
+  /** `code` : identifiant stable exploité par l'administration (ex. PASSWORD_CHANGE_REQUIRED). */
+  constructor(public status: number, message: string, public code?: string) {
+    super(message);
+  }
+}
+
+type Handler = (req: Request, res: Response, next: NextFunction) => unknown;
+
+function wrap(handler: Handler): RequestHandler {
+  return (req, res, next) => {
+    Promise.resolve(handler(req, res, next)).catch(next);
+  };
+}
+
+/** Router dont les handlers async propagent leurs erreurs au middleware d'erreur (Express 4). */
+export function asyncRouter(): Router {
+  const router = Router();
+  for (const method of ['get', 'post', 'put', 'patch', 'delete'] as const) {
+    const original = router[method].bind(router) as (path: string, ...h: Handler[]) => Router;
+    (router as unknown as Record<string, unknown>)[method] = (path: string, ...handlers: Handler[]) =>
+      original(path, ...handlers.map(wrap));
+  }
+  return router;
+}
+
+/** Pagination des listes : `?page=` (≥ 1) et `?pageSize=` borné entre 10 et 100. */
+export function paging(query: Record<string, unknown>, defaultSize = 25): { page: number; pageSize: number } {
+  const size = Number(query.pageSize);
+  return {
+    page: Math.max(1, Math.floor(Number(query.page)) || 1),
+    pageSize: Number.isFinite(size) && size > 0 ? Math.min(Math.max(Math.floor(size), 10), 100) : defaultSize,
+  };
+}
+
+export function apiErrorHandler(err: unknown, _req: Request, res: Response, _next: NextFunction) {
+  const bodyError = (err as { type?: string })?.type === 'entity.too.large';
+  const status = err instanceof HttpError ? err.status : bodyError ? 413 : 500;
+  const message = bodyError ? 'Requête trop volumineuse' : err instanceof Error ? err.message : 'Erreur serveur';
+  if (status >= 500) console.error('[api]', err);
+  res.status(status).json({
+    error: err instanceof HttpError || status < 500 ? message : 'Erreur serveur',
+    ...(err instanceof HttpError && err.code ? { code: err.code } : {}),
+  });
+}

package/template/server/mail.ts

@@ -0,0 +1,216 @@
+/**
+ * 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 nodemailer, { type Transporter } from 'nodemailer';
+import { desc, lt, sql } from 'drizzle-orm';
+import { loadSnapshot } from './cms/store';
+import type { CmsSnapshot, SmtpSettings } from './cms/types';
+import { db } from './db/client';
+import { mailLog } from './db/schema';
+import { decryptSecret } from './security/secrets';
+
+export type SmtpSource = 'settings' | 'env' | 'none';
+
+interface ResolvedSmtp {
+  source: Exclude<SmtpSource, 'none'>;
+  transport: Parameters<typeof nodemailer.createTransport>[0];
+  from: string;
+  replyTo?: string;
+}
+
+const quoteName = (name: string) => `"${name.replace(/["\\]/g, '')}"`;
+
+/** Paramètres SMTP effectifs : réglages de l'administration, sinon variables SMTP_* du fichier .env. */
+export function resolveSmtp(smtp: SmtpSettings, siteName: string, passwordOverride?: string): ResolvedSmtp | null {
+  if (smtp.enabled && smtp.host) {
+    const pass = passwordOverride ?? decryptSecret(smtp.passwordEnc) ?? '';
+    const fromEmail = smtp.fromEmail || smtp.username;
+    return {
+      source: 'settings',
+      transport: {
+        host: smtp.host,
+        port: smtp.port,
+        secure: smtp.security === 'ssl',
+        requireTLS: smtp.security === 'starttls',
+        ignoreTLS: smtp.security === 'none',
+        auth: smtp.username ? { user: smtp.username, pass } : undefined,
+        connectionTimeout: smtp.timeoutSec * 1000,
+        greetingTimeout: smtp.timeoutSec * 1000,
+        socketTimeout: smtp.timeoutSec * 1000 * 2,
+        tls: { rejectUnauthorized: !smtp.allowSelfSigned },
+      },
+      from: `${quoteName(smtp.fromName || siteName)} <${fromEmail}>`,
+      replyTo: smtp.replyTo || undefined,
+    };
+  }
+  if (process.env.SMTP_HOST) {
+    const port = Number(process.env.SMTP_PORT || 587);
+    const secure = process.env.SMTP_SECURE === 'true' || port === 465;
+    return {
+      source: 'env',
+      transport: {
+        host: process.env.SMTP_HOST,
+        port,
+        secure,
+        requireTLS: !secure && port === 587,
+        auth: process.env.SMTP_USER ? { user: process.env.SMTP_USER, pass: process.env.SMTP_PASS || '' } : undefined,
+        connectionTimeout: 20_000,
+        greetingTimeout: 20_000,
+      },
+      from: process.env.SMTP_FROM || `${quoteName(siteName)} <noreply@snapify.fr>`,
+    };
+  }
+  return null;
+}
+
+export const smtpSource = (s: CmsSnapshot): SmtpSource => resolveSmtp(s.system.smtp, s.branding.siteName)?.source ?? 'none';
+
+let cached: { key: string; transporter: Transporter } | null = null;
+
+function transporterFor(cfg: ResolvedSmtp): Transporter {
+  const key = JSON.stringify(cfg.transport);
+  if (cached?.key !== key) {
+    cached?.transporter.close();
+    cached = { key, transporter: nodemailer.createTransport(cfg.transport) };
+  }
+  return cached.transporter;
+}
+
+async function logMail(kind: string, to: string | string[], subject: string, status: 'sent' | 'failed' | 'skipped', error?: string) {
+  try {
+    await db.insert(mailLog).values({
+      kind,
+      toAddr: (Array.isArray(to) ? to.join(', ') : to).slice(0, 500),
+      subject: subject.slice(0, 300),
+      status,
+      error: error?.slice(0, 500),
+    });
+  } catch (e) {
+    console.error('[mail] journal impossible', e);
+  }
+}
+
+export type MailKind = 'form' | 'newsletter' | 'invite' | 'reset' | 'security' | 'notification' | 'test' | 'system';
+
+/** Envoie un e-mail sans jamais lever d'exception : le résultat est journalisé. */
+export async function sendMail(options: {
+  to: string | string[];
+  subject: string;
+  html: string;
+  text?: string;
+  kind?: MailKind;
+  replyTo?: string;
+}): Promise<{ sent: boolean; reason?: string }> {
+  const kind = options.kind ?? 'system';
+  const recipients = Array.isArray(options.to) ? options.to.filter(Boolean) : options.to;
+  if (!recipients.length) return { sent: false, reason: 'Aucun destinataire' };
+  const s = await loadSnapshot();
+  const cfg = resolveSmtp(s.system.smtp, s.branding.siteName);
+  if (!cfg) {
+    console.warn('[mail] SMTP non configuré — e-mail non envoyé:', options.subject);
+    await logMail(kind, recipients, options.subject, 'skipped', 'SMTP non configuré');
+    return { sent: false, reason: 'SMTP non configuré' };
+  }
+  try {
+    await transporterFor(cfg).sendMail({
+      from: cfg.from,
+      to: recipients,
+      replyTo: options.replyTo ?? cfg.replyTo,
+      subject: options.subject,
+      html: options.html,
+      text: options.text,
+    });
+    await logMail(kind, recipients, options.subject, 'sent');
+    return { sent: true };
+  } catch (e) {
+    const reason = e instanceof Error ? e.message : String(e);
+    console.error('[mail] échec d’envoi', reason);
+    await logMail(kind, recipients, options.subject, 'failed', reason);
+    return { sent: false, reason };
+  }
+}
+
+/** Vérifie une configuration (éventuellement non enregistrée) et envoie un message de test. */
+export async function testSmtp(smtp: SmtpSettings, to: string, passwordOverride?: string): Promise<{ ok: boolean; error?: string; source: SmtpSource }> {
+  const s = await loadSnapshot();
+  const cfg = resolveSmtp(smtp, s.branding.siteName, passwordOverride);
+  if (!cfg) return { ok: false, error: 'Aucun serveur SMTP configuré', source: 'none' };
+  const transporter = nodemailer.createTransport(cfg.transport);
+  const subject = `Test d’envoi — ${s.branding.siteName}`;
+  try {
+    await transporter.verify();
+    const { html, text } = renderEmail(s, {
+      title: 'Votre configuration e-mail fonctionne',
+      intro: `Ce message de test a été envoyé depuis l’administration de ${s.branding.siteName}.`,
+      lines: [`Serveur : ${smtp.enabled ? `${smtp.host}:${smtp.port}` : 'configuration du fichier .env'}`],
+    });
+    await transporter.sendMail({ from: cfg.from, to, replyTo: cfg.replyTo, subject, html, text });
+    await logMail('test', to, subject, 'sent');
+    return { ok: true, source: cfg.source };
+  } catch (e) {
+    const error = e instanceof Error ? e.message : String(e);
+    await logMail('test', to, subject, 'failed', error);
+    return { ok: false, error, source: cfg.source };
+  } finally {
+    transporter.close();
+  }
+}
+
+export function escapeHtml(v: unknown): string {
+  return String(v ?? '')
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+/** Gabarit e-mail aux couleurs du site (HTML compatible clients mail + version texte). */
+export function renderEmail(
+  s: CmsSnapshot,
+  /** `html` : fragment déjà échappé (tableau récapitulatif…) inséré après les lignes. */
+  content: { title: string; intro: string; lines?: string[]; button?: { label: string; url: string }; outro?: string; html?: string }
+): { html: string; text: string } {
+  const color = s.branding.colors?.primary || '#2563eb';
+  const site = escapeHtml(s.branding.siteName);
+  const p = (t: string) => `<p style="margin:0 0 14px;font-size:15px;line-height:1.6;color:#334155">${escapeHtml(t)}</p>`;
+  const html = `<!doctype html><html lang="fr"><body style="margin:0;background:#f1f5f9;font-family:-apple-system,Segoe UI,Roboto,Helvetica,Arial,sans-serif">
+<table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="background:#f1f5f9;padding:32px 12px"><tr><td align="center">
+<table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="max-width:560px;background:#ffffff;border-radius:14px;overflow:hidden;border:1px solid #e2e8f0">
+<tr><td style="background:${color};padding:18px 28px;color:#ffffff;font-weight:700;font-size:17px">${site}</td></tr>
+<tr><td style="padding:28px">
+<h1 style="margin:0 0 16px;font-size:20px;color:#0f172a">${escapeHtml(content.title)}</h1>
+${p(content.intro)}
+${(content.lines ?? []).map(p).join('')}
+${content.html ?? ''}
+${content.button ? `<p style="margin:24px 0"><a href="${escapeHtml(content.button.url)}" style="display:inline-block;background:${color};color:#ffffff;text-decoration:none;font-weight:600;padding:12px 22px;border-radius:9px">${escapeHtml(content.button.label)}</a></p><p style="margin:0 0 14px;font-size:12px;color:#64748b;word-break:break-all">${escapeHtml(content.button.url)}</p>` : ''}
+${content.outro ? p(content.outro) : ''}
+</td></tr>
+<tr><td style="padding:16px 28px;background:#f8fafc;font-size:12px;color:#94a3b8">Message automatique envoyé par ${site}.</td></tr>
+</table></td></tr></table></body></html>`;
+  const text = [
+    content.title,
+    '',
+    content.intro,
+    ...(content.lines ?? []),
+    ...(content.button ? ['', `${content.button.label} : ${content.button.url}`] : []),
+    ...(content.outro ? ['', content.outro] : []),
+  ].join('\n');
+  return { html, text };
+}
+
+export async function listMailLog(page: number, pageSize: number) {
+  const [items, [{ total }]] = await Promise.all([
+    db.select().from(mailLog).orderBy(desc(mailLog.ts), desc(mailLog.id)).limit(pageSize).offset((page - 1) * pageSize),
+    db.select({ total: sql<number>`count(*)::int` }).from(mailLog),
+  ]);
+  return { items, total };
+}
+
+export async function purgeMailLog(days: number): Promise<number> {
+  if (days <= 0) return 0;
+  const rows = await db.delete(mailLog).where(lt(mailLog.ts, new Date(Date.now() - days * 86400_000))).returning({ id: mailLog.id });
+  return rows.length;
+}

package/template/server/marketplace/catalog.ts

@@ -0,0 +1,74 @@
+/**
+ * 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 { desc, eq } from 'drizzle-orm';
+import { db } from '../db/client';
+import { mpProducts, mpPublishers, mpVersions, platformUsers } from '../db/schema';
+import { compareVersions } from '../../sdk/package';
+
+/** Catalogue compatible avec server/modules/marketplace.ts (format snapify-catalog/1). */
+export async function buildCmsCatalog() {
+  const products = await db.select().from(mpProducts).where(eq(mpProducts.status, 'published'));
+  const versions = await db.select().from(mpVersions).orderBy(desc(mpVersions.createdAt));
+  const publishers = await db.select().from(mpPublishers);
+  const users = await db.select().from(platformUsers);
+
+  const pubById = new Map(publishers.map((p) => [p.id, p]));
+  const userById = new Map(users.map((u) => [u.id, u]));
+  /** Version signée la plus élevée : une mise à jour en attente de revue ne masque pas la version publiée. */
+  const latest = new Map<string, (typeof versions)[0]>();
+  for (const v of versions) {
+    if (!v.signed) continue;
+    const cur = latest.get(v.productId);
+    if (!cur || compareVersions(v.version, cur.version) > 0) latest.set(v.productId, v);
+  }
+
+  const base = (
+    process.env.MARKETPLACE_PUBLIC_URL ||
+    process.env.PLATFORM_PUBLIC_URL ||
+    process.env.MARKETPLACE_URL ||
+    ''
+  )
+    .replace(/\/$/, '')
+    .replace(/\/api\/.*$/, '');
+
+  const modules = products
+    .map((p) => {
+      const ver = latest.get(p.id);
+      if (!ver || !ver.signed) return null;
+      const pub = pubById.get(p.publisherId);
+      const authorUser = pub ? userById.get(pub.userId) : null;
+      return {
+        id: ver.moduleId || (p.slug.includes('.') ? p.slug : `community.${p.slug}`),
+        kind: p.kind,
+        name: p.name,
+        version: ver.version,
+        description: p.shortDesc,
+        author: {
+          name: pub?.displayName || authorUser?.displayName || 'Community',
+          email: authorUser?.email || 'marketplace@snapify.tn',
+          url: pub?.website || undefined,
+        },
+        pricing: p.priceMillimes === 0 ? 'free' : 'paid',
+        category: p.category,
+        icon: p.icon,
+        permissions: p.permissions,
+        engines: p.engines,
+        package: `${base}/api/marketplace/packages/${ver.id}/download-public`,
+        sha256: ver.sha256,
+        size: ver.size,
+        signed: ver.signed,
+        screenshot: p.screenshots[0],
+      };
+    })
+    .filter(Boolean);
+
+  return {
+    format: 'snapify-catalog/1',
+    generatedAt: new Date().toISOString(),
+    modules,
+  };
+}