create-snapify-app 0.0.0-stage → 1.1.1

package/template/server/platform/clients.ts

@@ -0,0 +1,139 @@
+/**
+ * Snapify — fiches clients (demandes de site / licences)
+ * © 2026 NOVALABS WEB DESIGN — Tunisie
+ */
+import crypto from 'crypto';
+import { desc, eq } from 'drizzle-orm';
+import { db } from '../db/client';
+import { clientProfiles, platformUsers } from '../db/schema';
+import type { LicenseOrder } from './licenseOrders';
+
+export type ClientProfile = typeof clientProfiles.$inferSelect;
+
+function id() {
+  return crypto.randomUUID();
+}
+
+export function marketFromHost(host: string): 'tn' | 'fr' {
+  const h = host.toLowerCase();
+  if (h.includes('.fr') || h.endsWith('fr')) return 'fr';
+  return 'tn';
+}
+
+/** Crée ou met à jour la fiche client dès qu’une demande licence est déposée. */
+export async function ensureClientFromLicenseOrder(
+  order: LicenseOrder,
+  opts: { market?: 'tn' | 'fr'; country?: string } = {}
+): Promise<ClientProfile> {
+  const email = order.email.trim().toLowerCase();
+  const market = opts.market || 'tn';
+  const country = (opts.country || (market === 'fr' ? 'FR' : 'TN')).toUpperCase().slice(0, 2);
+
+  const [existing] = await db.select().from(clientProfiles).where(eq(clientProfiles.email, email)).limit(1);
+  const orderIds = existing?.licenseOrderIds?.includes(order.id)
+    ? existing.licenseOrderIds
+    : [...(existing?.licenseOrderIds || []), order.id];
+
+  // Lier un compte plateforme existant (même e-mail)
+  let platformUserId = existing?.platformUserId || null;
+  if (!platformUserId) {
+    const [u] = await db.select({ id: platformUsers.id }).from(platformUsers).where(eq(platformUsers.email, email)).limit(1);
+    if (u) platformUserId = u.id;
+  }
+
+  const nextStatus =
+    order.status === 'paid' ? ('active' as const) : existing?.status === 'active' ? ('active' as const) : ('lead' as const);
+
+  if (existing) {
+    const [updated] = await db
+      .update(clientProfiles)
+      .set({
+        name: order.name || existing.name,
+        phone: order.details?.phone || existing.phone,
+        company: order.details?.company || existing.company,
+        domain: order.domain || existing.domain,
+        market: existing.market || market,
+        country: country || existing.country,
+        status: nextStatus,
+        licenseOrderIds: orderIds,
+        platformUserId,
+        updatedAt: new Date(),
+      })
+      .where(eq(clientProfiles.id, existing.id))
+      .returning();
+    return updated;
+  }
+
+  const [created] = await db
+    .insert(clientProfiles)
+    .values({
+      id: id(),
+      platformUserId,
+      email,
+      name: order.name,
+      phone: order.details?.phone || '',
+      company: order.details?.company || '',
+      domain: order.domain,
+      market,
+      country,
+      status: nextStatus,
+      licenseOrderIds: orderIds,
+    })
+    .returning();
+  return created;
+}
+
+/** Lie la fiche à un user plateforme après login/register. */
+export async function linkClientProfileToUser(email: string, userId: string): Promise<ClientProfile | null> {
+  const e = email.trim().toLowerCase();
+  const [row] = await db.select().from(clientProfiles).where(eq(clientProfiles.email, e)).limit(1);
+  if (!row) return null;
+  if (row.platformUserId === userId) return row;
+  const [updated] = await db
+    .update(clientProfiles)
+    .set({ platformUserId: userId, updatedAt: new Date() })
+    .where(eq(clientProfiles.id, row.id))
+    .returning();
+  return updated;
+}
+
+export async function getClientByUserId(userId: string): Promise<ClientProfile | null> {
+  const [byUser] = await db.select().from(clientProfiles).where(eq(clientProfiles.platformUserId, userId)).limit(1);
+  if (byUser) return byUser;
+  const [u] = await db.select().from(platformUsers).where(eq(platformUsers.id, userId)).limit(1);
+  if (!u) return null;
+  return linkClientProfileToUser(u.email, userId);
+}
+
+export async function getClientByEmail(email: string): Promise<ClientProfile | null> {
+  const [row] = await db.select().from(clientProfiles).where(eq(clientProfiles.email, email.trim().toLowerCase())).limit(1);
+  return row || null;
+}
+
+export async function listClientProfiles(opts: { status?: string; q?: string } = {}) {
+  let items = await db.select().from(clientProfiles).orderBy(desc(clientProfiles.createdAt));
+  if (opts.status && opts.status !== 'all') items = items.filter((r) => r.status === opts.status);
+  if (opts.q) {
+    const q = opts.q.toLowerCase();
+    items = items.filter(
+      (r) =>
+        r.email.includes(q) ||
+        r.name.toLowerCase().includes(q) ||
+        r.domain.toLowerCase().includes(q) ||
+        r.company.toLowerCase().includes(q)
+    );
+  }
+  return items;
+}
+
+export async function updateClientProfile(
+  id: string,
+  patch: Partial<Pick<ClientProfile, 'name' | 'phone' | 'company' | 'domain' | 'status' | 'notes' | 'market' | 'country'>>
+) {
+  const [updated] = await db
+    .update(clientProfiles)
+    .set({ ...patch, updatedAt: new Date() })
+    .where(eq(clientProfiles.id, id))
+    .returning();
+  return updated || null;
+}

package/template/server/platform/dailyImprove.ts

@@ -0,0 +1,356 @@
+/**
+ * Cron quotidien — améliore SEO + santé marketplace (devs) + rapport superadmin.
+ * Pas de spam backlinks : actions mesurables et sûres pour Google.
+ */
+import { count, eq } from 'drizzle-orm';
+import { db } from '../db/client';
+import { mpProducts, mpPublishers, mpSettings } from '../db/schema';
+import { getLandingSeo, getSeoBacklinks } from '../superadmin/landingSeo';
+import { BACKLINK_CATALOG } from '../superadmin/backlinksCatalog';
+import { buildCmsCatalog } from '../marketplace/catalog';
+
+export type DailyImproveAction = {
+  id: string;
+  ok: boolean;
+  detail: string;
+};
+
+export type DailyImproveReport = {
+  ranAt: string;
+  durationMs: number;
+  score: number;
+  actions: DailyImproveAction[];
+  marketplace: {
+    published: number;
+    pendingReview: number;
+    draft: number;
+    publishersPending: number;
+    publishersActive: number;
+    missingScreenshot: number;
+    missingDesc: number;
+    catalogModules: number;
+  };
+  seo: {
+    ga4: boolean;
+    gsc: boolean;
+    bing: boolean;
+    indexNow: boolean;
+    backlinksLive: number;
+    backlinksTodo: number;
+    backlinksTotal: number;
+  };
+  health: { url: string; status: number | 'error' }[];
+  nextTips: string[];
+};
+
+const REPORT_KEY = 'dailyImproveReport';
+const META_KEY = 'dailyImproveMeta';
+
+async function saveReport(report: DailyImproveReport) {
+  await db
+    .insert(mpSettings)
+    .values({ key: REPORT_KEY, value: report as never, updatedAt: new Date() })
+    .onConflictDoUpdate({ target: mpSettings.key, set: { value: report as never, updatedAt: new Date() } });
+  await db
+    .insert(mpSettings)
+    .values({
+      key: META_KEY,
+      value: { lastRunAt: report.ranAt, score: report.score } as never,
+      updatedAt: new Date(),
+    })
+    .onConflictDoUpdate({
+      target: mpSettings.key,
+      set: { value: { lastRunAt: report.ranAt, score: report.score } as never, updatedAt: new Date() },
+    });
+}
+
+export async function getDailyImproveReport(): Promise<DailyImproveReport | null> {
+  const [row] = await db.select().from(mpSettings).where(eq(mpSettings.key, REPORT_KEY)).limit(1);
+  if (!row || typeof row.value !== 'object' || !row.value) return null;
+  return row.value as DailyImproveReport;
+}
+
+async function headStatus(url: string): Promise<number | 'error'> {
+  try {
+    const res = await fetch(url, {
+      method: 'GET',
+      redirect: 'follow',
+      signal: AbortSignal.timeout(12_000),
+      headers: { 'User-Agent': 'SnapifyDailyImprove/1.0' },
+    });
+    return res.status;
+  } catch {
+    return 'error';
+  }
+}
+
+async function pingIndexNow(urls: string[], key: string): Promise<DailyImproveAction> {
+  if (!key.trim()) {
+    return { id: 'indexnow', ok: false, detail: 'Clé IndexNow absente — à définir dans SEO → Technique.' };
+  }
+  const host = urls[0]?.includes('snapify.fr') ? 'snapify.fr' : 'snapify.tn';
+  try {
+    const res = await fetch('https://api.indexnow.org/indexnow', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json; charset=utf-8' },
+      body: JSON.stringify({
+        host,
+        key,
+        keyLocation: `https://${host}/${key}.txt`,
+        urlList: urls.slice(0, 40),
+      }),
+      signal: AbortSignal.timeout(20_000),
+    });
+    return {
+      id: 'indexnow',
+      ok: res.ok || res.status === 202,
+      detail: `IndexNow HTTP ${res.status} · ${urls.length} URLs (TN+FR hub)`,
+    };
+  } catch (e) {
+    return { id: 'indexnow', ok: false, detail: e instanceof Error ? e.message : 'IndexNow échoué' };
+  }
+}
+
+/** Une passe d’amélioration quotidienne. */
+export async function runDailyImprove(opts?: { triggeredBy?: string }): Promise<DailyImproveReport> {
+  const t0 = Date.now();
+  const actions: DailyImproveAction[] = [];
+  const seo = await getLandingSeo();
+  const tracks = (await getSeoBacklinks()).tracks;
+
+  // —— Marketplace / développeurs
+  const [[pubCount]] = await Promise.all([db.select({ n: count() }).from(mpProducts).where(eq(mpProducts.status, 'published'))]);
+  const [[pendCount]] = await Promise.all([db.select({ n: count() }).from(mpProducts).where(eq(mpProducts.status, 'pending'))]);
+  const [[draftCount]] = await Promise.all([db.select({ n: count() }).from(mpProducts).where(eq(mpProducts.status, 'draft'))]);
+  const [[pubPend]] = await Promise.all([
+    db.select({ n: count() }).from(mpPublishers).where(eq(mpPublishers.status, 'pending')),
+  ]);
+  const [[pubActive]] = await Promise.all([
+    db.select({ n: count() }).from(mpPublishers).where(eq(mpPublishers.status, 'active')),
+  ]);
+
+  const published = await db.select().from(mpProducts).where(eq(mpProducts.status, 'published'));
+  const missingScreenshot = published.filter((p) => !p.screenshots?.length).length;
+  const missingDesc = published.filter((p) => !(p.shortDesc || '').trim() || (p.shortDesc || '').trim().length < 40).length;
+
+  let catalogModules = 0;
+  try {
+    const cat = await buildCmsCatalog();
+    catalogModules = cat.modules.length;
+    // Touche le cache catalogue (timestamp frais pour les sites qui poll)
+    await db
+      .insert(mpSettings)
+      .values({ key: 'marketplaceCatalogCache', value: cat as never, updatedAt: new Date() })
+      .onConflictDoUpdate({ target: mpSettings.key, set: { value: cat as never, updatedAt: new Date() } });
+    actions.push({
+      id: 'marketplace-catalog',
+      ok: true,
+      detail: `Catalogue régénéré · ${catalogModules} modules/thèmes signés publiés`,
+    });
+  } catch (e) {
+    actions.push({
+      id: 'marketplace-catalog',
+      ok: false,
+      detail: e instanceof Error ? e.message : 'Catalogue marketplace échoué',
+    });
+  }
+
+  if (pendCount.n > 0) {
+    actions.push({
+      id: 'marketplace-pending-review',
+      ok: false,
+      detail: `${pendCount.n} produit(s) en attente de validation — prioritaire pour les devs marketplace`,
+    });
+  } else {
+    actions.push({ id: 'marketplace-pending-review', ok: true, detail: 'Aucune file d’attente produit' });
+  }
+
+  if (pubPend.n > 0) {
+    actions.push({
+      id: 'marketplace-publishers',
+      ok: false,
+      detail: `${pubPend.n} éditeur(s) en attente d’activation`,
+    });
+  } else {
+    actions.push({ id: 'marketplace-publishers', ok: true, detail: `${pubActive.n} éditeur(s) actifs` });
+  }
+
+  if (missingScreenshot > 0 || missingDesc > 0) {
+    actions.push({
+      id: 'marketplace-quality',
+      ok: false,
+      detail: `${missingScreenshot} sans screenshot · ${missingDesc} descriptions trop courtes — à corriger côté éditeurs`,
+    });
+  } else {
+    actions.push({ id: 'marketplace-quality', ok: true, detail: 'Fiches produits publiées : screenshots + descriptions OK' });
+  }
+
+  // —— Santé URLs publiques
+  const urls = [
+    'https://snapify.tn/',
+    'https://snapify.fr/',
+    'https://snapify.fr/creation-site-web-france',
+    'https://snapify.tn/creation-site-web-tunisie',
+    'https://snapify.fr/seo-france',
+    'https://snapify.tn/seo-tunisie',
+    'https://marketplace.snapify.tn/',
+    'https://marketplace.snapify.fr/',
+    'https://community.snapify.tn/',
+    'https://developers.snapify.tn/',
+    'https://developers.snapify.fr/',
+    'https://snapify.tn/sitemap.xml',
+    'https://snapify.fr/sitemap.xml',
+    'https://snapify.tn/llms.txt',
+  ];
+  const health: DailyImproveReport['health'] = [];
+  for (const url of urls) {
+    const status = await headStatus(url);
+    health.push({ url, status });
+  }
+  const bad = health.filter((h) => h.status === 'error' || (typeof h.status === 'number' && h.status >= 400));
+  actions.push({
+    id: 'health-urls',
+    ok: bad.length === 0,
+    detail: bad.length === 0 ? `${health.length} URLs OK` : `${bad.length} URL(s) en erreur : ${bad.map((b) => b.url).join(', ')}`,
+  });
+
+  // —— IndexNow
+  const indexUrls = [
+    'https://snapify.tn/',
+    'https://snapify.fr/',
+    'https://snapify.fr/creation-site-web-france',
+    'https://snapify.tn/creation-site-web-tunisie',
+    'https://snapify.fr/seo-france',
+    'https://snapify.tn/seo-tunisie',
+    'https://snapify.fr/alternative-wordpress',
+    'https://marketplace.snapify.tn/',
+    'https://marketplace.snapify.fr/',
+    'https://developers.snapify.tn/',
+    'https://developers.snapify.fr/',
+  ];
+  actions.push(await pingIndexNow(indexUrls, seo.indexNowKey || ''));
+
+  // —— Backlinks progression
+  const live = tracks.filter((t) => t.status === 'live').length;
+  const todo = tracks.filter((t) => t.status === 'todo' || t.status === 'in_progress').length;
+  const p1Todo = BACKLINK_CATALOG.filter((l) => l.priority === 1).filter((l) => {
+    const st = tracks.find((t) => t.id === l.id)?.status || 'todo';
+    return st === 'todo' || st === 'in_progress';
+  }).length;
+  actions.push({
+    id: 'backlinks',
+    ok: live > 0 || todo === 0,
+    detail: `${live} live · ${todo} à traiter · ${p1Todo} priorités P1 restantes (dont marketplace/devs)`,
+  });
+
+  // —— Score global
+  let score = 40;
+  if (seo.ga4Id) score += 15;
+  if (seo.googleSiteVerification) score += 10;
+  if (seo.bingSiteVerification) score += 5;
+  if (seo.indexNowKey) score += 10;
+  if (bad.length === 0) score += 10;
+  if (pendCount.n === 0) score += 5;
+  if (missingScreenshot === 0 && missingDesc === 0) score += 5;
+  score += Math.min(10, live);
+  score = Math.max(0, Math.min(100, score));
+
+  const nextTips: string[] = [];
+  if (!seo.googleSiteVerification) nextTips.push('Coller le code meta Search Console (si vérif HTML) dans SEO → Technique.');
+  if (!seo.indexNowKey) nextTips.push('Générer une clé IndexNow (Bing) pour accélérer l’indexation quotidienne.');
+  if (p1Todo > 0) nextTips.push(`Soumettre ${Math.min(5, p1Todo)} backlinks P1 aujourd’hui (Product Hunt, G2, AlternativeTo…).`);
+  if (pendCount.n > 0) nextTips.push(`Valider ${pendCount.n} produit(s) marketplace en attente — les devs attendent.`);
+  if (missingScreenshot > 0) nextTips.push('Demander aux éditeurs d’ajouter des screenshots (conversion marketplace).');
+  if (live < 10) nextTips.push('Objectif : 10+ backlinks live avant de pousser Google Ads agressivement.');
+  nextTips.push('Google Ads : campagne exacte sur « création site web france » → /creation-site-web-france');
+
+  actions.push({
+    id: 'trigger',
+    ok: true,
+    detail: opts?.triggeredBy ? `Déclenché par ${opts.triggeredBy}` : 'Cron automatique quotidien',
+  });
+
+  const report: DailyImproveReport = {
+    ranAt: new Date().toISOString(),
+    durationMs: Date.now() - t0,
+    score,
+    actions,
+    marketplace: {
+      published: Number(pubCount.n),
+      pendingReview: Number(pendCount.n),
+      draft: Number(draftCount.n),
+      publishersPending: Number(pubPend.n),
+      publishersActive: Number(pubActive.n),
+      missingScreenshot,
+      missingDesc,
+      catalogModules,
+    },
+    seo: {
+      ga4: !!seo.ga4Id,
+      gsc: !!seo.googleSiteVerification,
+      bing: !!seo.bingSiteVerification,
+      indexNow: !!seo.indexNowKey,
+      backlinksLive: live,
+      backlinksTodo: todo,
+      backlinksTotal: BACKLINK_CATALOG.length,
+    },
+    health,
+    nextTips,
+  };
+
+  await saveReport(report);
+  console.log(
+    `[daily-improve] score=${score} marketplace pending=${pendCount.n} catalog=${catalogModules} live-backlinks=${live} (${report.durationMs}ms)`
+  );
+  return report;
+}
+
+/**
+ * Planifie une exécution ~03:00 heure serveur + garde-fou si dernier run > 20 h.
+ */
+export function startDailyImproveScheduler() {
+  const DAY = 24 * 3600 * 1000;
+  let running = false;
+
+  const tick = async (reason: string) => {
+    if (running) return;
+    running = true;
+    try {
+      await runDailyImprove({ triggeredBy: reason });
+    } catch (e) {
+      console.error('[daily-improve] échec', e);
+    } finally {
+      running = false;
+    }
+  };
+
+  const msUntil3am = () => {
+    const now = new Date();
+    const next = new Date(now);
+    next.setHours(3, 5, 0, 0);
+    if (next.getTime() <= now.getTime()) next.setDate(next.getDate() + 1);
+    return next.getTime() - now.getTime();
+  };
+
+  // Premier run : si jamais exécuté ou > 20 h
+  void (async () => {
+    try {
+      const [row] = await db.select().from(mpSettings).where(eq(mpSettings.key, META_KEY)).limit(1);
+      const last = (row?.value as { lastRunAt?: string } | null)?.lastRunAt;
+      const age = last ? Date.now() - new Date(last).getTime() : Infinity;
+      if (age > 20 * 3600 * 1000) {
+        // léger délai pour laisser le serveur finir de booter
+        setTimeout(() => void tick('boot-catchup'), 45_000).unref();
+      }
+    } catch (e) {
+      console.warn('[daily-improve] meta', e);
+    }
+  })();
+
+  setTimeout(() => {
+    void tick('scheduled-3am');
+    setInterval(() => void tick('scheduled-3am'), DAY).unref();
+  }, msUntil3am()).unref();
+
+  console.log(`[daily-improve] planifié — prochain passage dans ~${Math.round(msUntil3am() / 3600000)} h (03:05)`);
+}

package/template/server/platform/flouci.ts

@@ -0,0 +1,126 @@
+/**
+ * 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 crypto from 'crypto';
+import { getFlouciCredentials } from './settings';
+import { HttpError } from '../http';
+import { safeEqualStr } from '../security/secrets';
+
+const FLOUCI_API = 'https://developers.flouci.com/api/v2';
+
+export type GeneratePaymentInput = {
+  amountMillimes: number;
+  trackingId: string;
+  successLink: string;
+  failLink: string;
+  webhook: string;
+};
+
+export type GeneratePaymentResult = {
+  paymentId: string;
+  link: string;
+  raw: unknown;
+};
+
+function flouciMockAllowed() {
+  return process.env.FLOUCI_MOCK === 'true' && process.env.NODE_ENV !== 'production';
+}
+
+export async function generatePayment(input: GeneratePaymentInput): Promise<GeneratePaymentResult> {
+  // Mode développement sans clés réelles : lien simulé (interdit en production)
+  if (flouciMockAllowed()) {
+    const paymentId = `mock_${input.trackingId}`;
+    return {
+      paymentId,
+      link: `${input.successLink}${input.successLink.includes('?') ? '&' : '?'}payment_id=${paymentId}&mock=1`,
+      raw: { mock: true },
+    };
+  }
+  if (process.env.FLOUCI_MOCK === 'true' && process.env.NODE_ENV === 'production') {
+    throw new HttpError(503, 'FLOUCI_MOCK interdit en production.');
+  }
+
+  const creds = await getFlouciCredentials();
+  if (!creds) throw new HttpError(503, 'Paiement Flouci non configuré (clés manquantes).');
+
+  if (creds.publicKey === 'mock') {
+    const paymentId = `mock_${input.trackingId}`;
+    return {
+      paymentId,
+      link: `${input.successLink}${input.successLink.includes('?') ? '&' : '?'}payment_id=${paymentId}&mock=1`,
+      raw: { mock: true },
+    };
+  }
+
+  const res = await fetch(`${FLOUCI_API}/generate_payment`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${creds.publicKey}:${creds.privateKey}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      amount: String(input.amountMillimes),
+      developer_tracking_id: input.trackingId,
+      accept_card: true,
+      success_link: input.successLink,
+      fail_link: input.failLink,
+      webhook: input.webhook,
+      webhook_version: 2,
+    }),
+    signal: AbortSignal.timeout(20_000),
+  });
+
+  const raw = (await res.json().catch(() => ({}))) as Record<string, unknown>;
+  if (!res.ok) {
+    const msg = typeof raw.message === 'string' ? raw.message : `Flouci HTTP ${res.status}`;
+    throw new HttpError(502, msg);
+  }
+
+  const result = (raw.result || raw) as Record<string, unknown>;
+  const paymentId = String(result.payment_id || result.id || '');
+  const link = String(result.link || result.payment_url || result.redirect_url || '');
+  if (!paymentId || !link) throw new HttpError(502, 'Réponse Flouci invalide');
+  return { paymentId, link, raw };
+}
+
+/** Vérifie la signature webhook Flouci (HMAC SHA256 du corps brut). */
+export function verifyFlouciSignature(rawBody: string, signature: string | undefined): boolean {
+  const secret = process.env.FLOUCI_WEBHOOK_SECRET || '';
+  if (!secret) {
+    // Sans secret : accepter uniquement en mock hors production
+    return flouciMockAllowed();
+  }
+  if (!signature) return false;
+  const expected = crypto.createHmac('sha256', secret).update(rawBody).digest('hex');
+  return safeEqualStr(signature.replace(/^sha256=/i, ''), expected) || safeEqualStr(signature, expected);
+}
+
+export { flouciMockAllowed };
+
+export type FlouciWebhookEvent = {
+  type: 'payment.succeeded' | 'payment.failed' | string;
+  payment_id?: string;
+  developer_tracking_id?: string;
+  success?: boolean;
+  [key: string]: unknown;
+};
+
+export function parseFlouciWebhook(body: unknown): FlouciWebhookEvent {
+  const b = body as Record<string, unknown>;
+  const event = (b.event || b) as Record<string, unknown>;
+  const type = String(event.type || (event.success === true || event.success === 'True' ? 'payment.succeeded' : 'payment.failed'));
+  return {
+    type,
+    payment_id: event.payment_id ? String(event.payment_id) : b.payment_id ? String(b.payment_id) : undefined,
+    developer_tracking_id: event.developer_tracking_id
+      ? String(event.developer_tracking_id)
+      : b.developer_tracking_id
+        ? String(b.developer_tracking_id)
+        : undefined,
+    success: type === 'payment.succeeded' || event.success === true || event.success === 'True',
+    ...event,
+  };
+}

package/template/server/platform/host.ts

@@ -0,0 +1,69 @@
+/**
+ * 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 { Request } from 'express';
+
+export type AppHost = 'cms' | 'community' | 'marketplace' | 'developers';
+
+function hostFromReq(req: Request): string {
+  const xf = String(req.headers['x-forwarded-host'] || '')
+    .split(',')[0]
+    .trim();
+  const raw = xf || String(req.headers.host || '');
+  return raw.split(':')[0].toLowerCase();
+}
+
+/** Anciens sous-domaines client.* → à rediriger vers /espace-client sur l’apex. */
+export function isLegacyClientHost(host: string): boolean {
+  const h = host.toLowerCase().split(':')[0];
+  const list = (process.env.CLIENT_HOST || 'client.snapify.tn,client.snapify.fr,client.localhost')
+    .split(',')
+    .map((s) => s.trim().toLowerCase())
+    .filter(Boolean);
+  return list.includes(h) || h.startsWith('client.');
+}
+
+export function legacyClientRedirectUrl(host: string, originalUrl: string): string {
+  const h = host.toLowerCase();
+  const apex =
+    h.includes('.fr') || h.endsWith('fr')
+      ? 'https://snapify.fr'
+      : h.includes('localhost')
+        ? ''
+        : 'https://snapify.tn';
+  const [pathPart, ...qs] = (originalUrl || '/').split('?');
+  const query = qs.length ? `?${qs.join('?')}` : '';
+  let sub = pathPart === '/' ? '' : pathPart;
+  if (sub.startsWith('/espace-client')) sub = sub.slice('/espace-client'.length) || '';
+  const destPath = `/espace-client${sub}`;
+  return apex ? `${apex}${destPath}${query}` : `${destPath}${query}`;
+}
+
+export function resolveAppHost(req: Request): AppHost {
+  // Dev fallback : ?app=community|marketplace
+  const q = String((req.query as Record<string, unknown>)?.app || '');
+  if (q === 'community' || q === 'marketplace' || q === 'developers') return q;
+
+  const host = hostFromReq(req);
+  const list = (value: string | undefined, fallback: string) => (value || fallback).split(',').map((s) => s.trim().toLowerCase());
+  const community = list(
+    process.env.COMMUNITY_HOST,
+    'community.snapify.tn,community.snapify.fr,community.localhost'
+  );
+  const marketplace = list(
+    process.env.MARKETPLACE_HOST,
+    'marketplace.snapify.tn,marketplace.snapify.fr,marketplace.localhost'
+  );
+  const developers = list(
+    process.env.DEVELOPERS_HOST,
+    'developers.snapify.tn,developers.snapify.fr,developers.localhost'
+  );
+
+  if (community.includes(host)) return 'community';
+  if (marketplace.includes(host)) return 'marketplace';
+  if (developers.includes(host)) return 'developers';
+  return 'cms';
+}