nodefony 7.0.2 → 10.0.0-alpha.2

package/templates/app/base/vitest.config.ts.tpl

@@ -0,0 +1,88 @@
+import { existsSync, readdirSync } from "node:fs";
+import { defineConfig } from "vitest/config";
+
+/**
+ * Dit, à la fin d'un run, ce que ce run n'a PAS exercé.
+ *
+ * Sortir les e2e du glob évite un rapport « skipped » qui ferait croire qu'ils
+ * ont prouvé quelque chose — mais un rapport tout vert fait croire, tout autant,
+ * qu'il n'y avait rien d'autre à lancer. C'est arrivé, et ça a coûté cher : des
+ * tests e2e justes, écrits pour une route cassée, laissés dans le fichier que
+ * `npm test` exclut ; `npm test` vert ; « les tests passent » ; la route rendait
+ * 500 et ne répondait jamais.
+ *
+ * Le rappel s'affiche donc là où la personne — ou l'agent — regarde déjà : la
+ * sortie de la commande qu'elle vient de lancer. Il n'échoue pas : `npm test`
+ * doit rester le geste rapide. Il énonce.
+ */
+const direCeQuiNaPasTourné = {
+  // `onTestRunEnd` — et NON `onFinished`, qui subsiste dans les types de
+  // vitest 4 sans plus jamais être appelé : le rappel serait resté muet en
+  // passant le typecheck.
+  onTestRunEnd() {
+    if (!existsSync("tests")) {
+      return;
+    }
+    // Filtrer sur le NOM, jamais sur le chemin : `recursive` rend des chemins au
+    // séparateur natif, et un motif écrit en `/` ne mordrait pas sous Windows.
+    const nonExercés = readdirSync("tests", {
+      withFileTypes: true,
+      recursive: true,
+    })
+      .filter((e) => e.isFile() && /(^|\.)e2e\.test\.ts$/.test(e.name))
+      .map((e) => e.name)
+      // `toSorted` et non `sort` : le lint de l'application refuse les
+      // avertissements (`--deny-warnings`), et une app fraîche doit passer ses
+      // propres portes dès la première minute.
+      .toSorted();
+    if (nonExercés.length === 0) {
+      return;
+    }
+    console.log(
+      `\n⚠  npm test n'exécute PAS les tests de bout en bout — ` +
+        `${nonExercés.length} fichier(s) non exercé(s) :\n` +
+        `   ${nonExercés.join(", ")}\n` +
+        `   → npm run test:e2e   (build, puis boot RÉEL de l'app)\n` +
+        `   Ce run ne dit donc rien de ce que ces fichiers vérifient.\n`,
+    );
+  },
+};
+
+/**
+ * Config Vitest de l'app.
+ *
+ * ⚠️ Le bloc `oxc` est OBLIGATOIRE : Vitest transforme les tests via oxc/rolldown,
+ * qui ne lit PAS le `experimentalDecorators` du tsconfig. Sans lui, les décorateurs
+ * (@controller, @route, DI) sortiraient bruts et Node lèverait `SyntaxError` au
+ * chargement. `emitDecoratorMetadata` est requis par l'injection de dépendances
+ * (résolution des types constructeur via `design:paramtypes`).
+ *
+ * Deux suites, deux configs :
+ *   npm test          → tests unitaires (rapides, zéro serveur) — CETTE config
+ *   npm run test:e2e  → build + boot RÉEL de l'app + HTTP/WS (vitest.e2e.config.ts)
+ *
+ * Les e2e sont SORTIS du glob par défaut, pas « skippés » : un rapport qui
+ * affiche des tests skipped et sort vert fait croire qu'ils ont prouvé quelque
+ * chose. Ici `npm test` ne montre QUE ce qu'il a réellement exécuté — et le
+ * rappelle en fin de run, plutôt que de laisser son vert parler pour les suites
+ * qu'il n'a pas lancées (cf {@link direCeQuiNaPasTourné}).
+ */
+export default defineConfig({
+  test: {
+    reporters: ["default", direCeQuiNaPasTourné],
+    include: ["tests/**/*.test.ts"],
+    exclude: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "tests/e2e.test.ts",
+      // Tout fichier `*.e2e.test.ts` — `create entity` en ajoute un par
+      // ressource. Sans cette ligne, `npm test` les lancerait sans serveur et
+      // échouerait sur des `fetch` refusés, pour une raison sans rapport avec
+      // le code testé.
+      "tests/**/*.e2e.test.ts",
+    ],
+  },
+  oxc: {
+    decorator: { legacy: true, emitDecoratorMetadata: true },
+  },
+});

package/templates/app/base/vitest.e2e.config.ts.tpl

@@ -0,0 +1,39 @@
+import { defineConfig } from "vitest/config";
+
+/**
+ * Config Vitest des tests E2E — la SEULE porte vers les tests à boot réel
+ * (exclus de `vitest.config.ts`). L'invoquer, c'est vouloir un boot réel :
+ * `npm run test:e2e` (le build précède — un serveur spawné valide le DIST).
+ *
+ * L'application est démarrée UNE fois par `tests/e2e.setup.ts`, pas par chaque
+ * fichier : `create entity` ajoute un fichier E2E par ressource, et un
+ * démarrage par fichier rendrait la suite inutilisable.
+ *
+ * Les ressources posées dans un MODULE local sont ramassées ici aussi, et c'est
+ * la seule place possible : un module ne démarre pas seul, ses routes ne
+ * répondent que servies par l'application qui le charge. Sa suite unitaire les
+ * exclut donc, et c'est ce serveur-ci qui les sert.
+ *
+ * `fileParallelism: false` : tous les fichiers parlent au MÊME serveur. En
+ * parallèle, deux fichiers qui créent puis comptent des enregistrements se
+ * verraient mutuellement — les listes paginées deviendraient instables.
+ *
+ * Timeouts larges : un `nodefony production --detach --wait` compile puis
+ * sonde la readiness — c'est un vrai démarrage, pas un test unitaire.
+ */
+export default defineConfig({
+  test: {
+    include: [
+      "tests/e2e.test.ts",
+      "tests/**/*.e2e.test.ts",
+      "modules/*/tests/**/*.e2e.test.ts",
+    ],
+    globalSetup: ["tests/e2e.setup.ts"],
+    fileParallelism: false,
+    testTimeout: 180_000,
+    hookTimeout: 180_000,
+  },
+  oxc: {
+    decorator: { legacy: true, emitDecoratorMetadata: true },
+  },
+});

package/templates/app/complete/compose.yaml.tpl

@@ -0,0 +1,328 @@
+# <%= it.appName %> — infra de développement (docker compose)
+#
+# Ce fichier ne porte QUE ce que ton app utilise : le dialecte SQL a été retenu à
+# la création, les deux autres ne sont pas là. Ce qu'il fournit :
+#   - Redis    → sessions/idempotence partagées + backplane realtime multi-process
+<% if (it.db) { %>#   - <%= it.db.label %> → LA base de l'app — `NF_DATABASE_URL` est déjà posée dans
+#     `.env` sur ce service, il n'y a rien à câbler
+<% } %>#   - Loki + Grafana → centralisation des logs (driver `loki` du framework)
+#
+# Usage :
+#   docker compose up -d                          # Redis<%= it.db ? " + " + it.db.label : "" %> (ce qu'il faut à l'app)
+#   docker compose --profile tools up -d          # + RedisInsight (UI Redis)
+#   docker compose --profile loki up -d           # + Loki + Grafana (logs)
+#   docker compose --profile browser up -d        # + navigateur jetable (voir tes écrans)
+#   docker compose down                           # arrêt (volumes conservés)
+#   docker compose down -v                        # arrêt + PURGE des données
+#
+<% if (it.db) { %># Câblage côté app (env.ts est le SEUL lecteur de process.env) — `.env` porte
+# déjà l'URL de la base ; Redis reste commenté tant que tu n'en as pas besoin :
+#   NF_DATABASE_URL="<%= it.db.url %>"
+#   NF_REDIS_URL="redis://:<%= it.appName %>-dev@127.0.0.1:6379"
+<% } else { %># Base SQL : aucune ici — l'app persiste en sqlite local (`var/databases/`), ce
+# qui la fait démarrer sans rien allumer. Pour passer sur une vraie base, ajoute
+# son service et déclare `NF_DATABASE_URL` : l'ORM déduit le dialecte du scheme
+# (`postgres://`, `mysql://`) et RIEN d'autre ne change dans l'app.
+#
+# Câblage côté app (env.ts est le SEUL lecteur de process.env) :
+#   NF_REDIS_URL="redis://:<%= it.appName %>-dev@127.0.0.1:6379"
+<% } %>#
+# Config : chaque valeur a un défaut inline `${VAR:-défaut}` → AUCUN fichier .env requis.
+# Pour surcharger (autre port, vrai secret) : `export VAR=…` avant le `up`.
+# Les mots de passe dev sont PUBLICS — JAMAIS en production.
+#
+# Réseau : un bridge nommé unique ; les conteneurs se parlent par NOM de service
+# (DNS interne Docker), jamais par localhost. Les ports ne sont publiés que sur
+# 127.0.0.1 : l'app tourne sur l'HÔTE et joint l'infra via 127.0.0.1:<port>.
+
+name: <%= it.appName %>
+
+services:
+  # --- Redis (défaut — sessions, idempotence, backplane realtime) ---
+  # Auth obligatoire même en dev (Zero Trust). AOF : survit au restart du conteneur.
+  redis:
+    image: redis:7-alpine
+    container_name: <%= it.appName %>-redis
+    restart: unless-stopped
+    networks: [<%= it.appName %>]
+    command: >
+      redis-server
+      --requirepass ${REDIS_PASSWORD:-<%= it.appName %>-dev}
+      --appendonly yes
+      --maxmemory 256mb
+      --maxmemory-policy noeviction
+    ports:
+      # Loopback uniquement — surface réseau minimale en dev.
+      - "127.0.0.1:${REDIS_PORT:-6379}:6379"
+    volumes:
+      - redis-data:/data
+    healthcheck:
+      # -a : sans auth, PING renvoie NOAUTH. « healthy » = Redis répond PONG.
+      test:
+        [
+          "CMD-SHELL",
+          "redis-cli -a ${REDIS_PASSWORD:-<%= it.appName %>-dev} ping | grep -q PONG",
+        ]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+      start_period: 5s
+
+<% if (it.db && it.db.choice === "postgres") { %>  # --- PostgreSQL 16 — LA base de l'app (dialecte retenu à la création) ---
+  # Pas de `profiles:` : ce service n'est pas une option, c'est la base que
+  # `NF_DATABASE_URL` joint. `docker compose up -d` le monte avec Redis.
+  postgres:
+    image: <%= it.db.image %>
+    container_name: <%= it.appName %>-postgres
+    restart: unless-stopped
+    networks: [<%= it.appName %>]
+    environment:
+      POSTGRES_USER: ${POSTGRES_USER:-<%= it.appName %>}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-<%= it.appName %>-dev}
+      POSTGRES_DB: ${POSTGRES_DB:-<%= it.appName %>}
+    ports:
+      - "127.0.0.1:${POSTGRES_PORT:-5432}:5432"
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+      # Les deux bases de la suite e2e (du SQL, pas un script shell : un `.sh`
+      # exécutable dont le montage perd le bit tue le serveur au démarrage),
+      # créées à la PREMIÈRE initialisation du volume (`down -v` pour rejouer).
+      - ./docker/db:/docker-entrypoint-initdb.d:ro
+    healthcheck:
+      test:
+        [
+          "CMD-SHELL",
+          "pg_isready -U ${POSTGRES_USER:-<%= it.appName %>} -d ${POSTGRES_DB:-<%= it.appName %>}",
+        ]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+      start_period: 5s
+
+<% } %><% if (it.db && it.db.choice === "mariadb") { %>  # --- MariaDB 11.4 — LA base de l'app (fork libre de MySQL, même dialecte) ---
+  # Pas de `profiles:` : ce service n'est pas une option, c'est la base que
+  # `NF_DATABASE_URL` joint. `docker compose up -d` le monte avec Redis.
+  mariadb:
+    image: <%= it.db.image %>
+    container_name: <%= it.appName %>-mariadb
+    restart: unless-stopped
+    networks: [<%= it.appName %>]
+    environment:
+      MARIADB_ROOT_PASSWORD: ${MARIADB_ROOT_PASSWORD:-<%= it.appName %>-dev}
+      MARIADB_USER: ${MARIADB_USER:-<%= it.appName %>}
+      MARIADB_PASSWORD: ${MARIADB_PASSWORD:-<%= it.appName %>-dev}
+      MARIADB_DATABASE: ${MARIADB_DATABASE:-<%= it.appName %>}
+    ports:
+      - "127.0.0.1:${MARIADB_PORT:-3306}:3306"
+    volumes:
+      - mariadb-data:/var/lib/mysql
+      # Les deux bases de la suite e2e (du SQL, pas un script shell : un `.sh`
+      # exécutable dont le montage perd le bit tue le serveur au démarrage),
+      # créées à la PREMIÈRE initialisation du volume (`down -v` pour rejouer).
+      - ./docker/db:/docker-entrypoint-initdb.d:ro
+    healthcheck:
+      # healthcheck.sh = outil officiel de l'image mariadb.
+      test: ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"]
+      interval: 5s
+      timeout: 3s
+      retries: 10
+      start_period: 10s
+
+<% } %><% if (it.db && it.db.choice === "mysql") { %>  # --- MySQL 8.4 — LA base de l'app (dialecte retenu à la création) ---
+  # Pas de `profiles:` : ce service n'est pas une option, c'est la base que
+  # `NF_DATABASE_URL` joint. `docker compose up -d` le monte avec Redis.
+  mysql:
+    image: <%= it.db.image %>
+    container_name: <%= it.appName %>-mysql
+    restart: unless-stopped
+    networks: [<%= it.appName %>]
+    environment:
+      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD:-<%= it.appName %>-dev}
+      MYSQL_USER: ${MYSQL_USER:-<%= it.appName %>}
+      MYSQL_PASSWORD: ${MYSQL_PASSWORD:-<%= it.appName %>-dev}
+      MYSQL_DATABASE: ${MYSQL_DATABASE:-<%= it.appName %>}
+    ports:
+      # 3306 : le port décalé n'existait que pour cohabiter avec MariaDB dans un
+      # compose qui portait les deux — une app retient UN dialecte.
+      - "127.0.0.1:${MYSQL_PORT:-3306}:3306"
+    volumes:
+      - mysql-data:/var/lib/mysql
+      # Les deux bases de la suite e2e (du SQL, pas un script shell : un `.sh`
+      # exécutable dont le montage perd le bit tue le serveur au démarrage),
+      # créées à la PREMIÈRE initialisation du volume (`down -v` pour rejouer).
+      - ./docker/db:/docker-entrypoint-initdb.d:ro
+    healthcheck:
+      test:
+        [
+          "CMD-SHELL",
+          "mysqladmin ping -h 127.0.0.1 -u${MYSQL_USER:-<%= it.appName %>} -p${MYSQL_PASSWORD:-<%= it.appName %>-dev} --silent",
+        ]
+      interval: 5s
+      timeout: 3s
+      retries: 10
+      start_period: 10s
+
+<% } %>  # --- RedisInsight (profile tools — UI de debug Redis, jamais en prod) ---
+  redisinsight:
+    image: redis/redisinsight:latest
+    container_name: <%= it.appName %>-redisinsight
+    restart: unless-stopped
+    profiles: ["tools"]
+    networks: [<%= it.appName %>]
+    ports:
+      - "127.0.0.1:${REDISINSIGHT_PORT:-5540}:5540"
+    # Il garde SON état : la connexion enregistrée, les requêtes gardées, les
+    # préférences. Sans volume, on la ressaisit à chaque `compose down` — et un
+    # outil qu'on doit reconfigurer à chaque usage finit par ne plus servir.
+    volumes:
+      - redisinsight-data:/data
+    depends_on:
+      redis:
+        condition: service_healthy
+
+  # --- Loki (profile loki — centralisation des logs, driver `loki` du framework) ---
+  # Léger : Loki indexe les LABELS (basse cardinalité), pas le texte → peu de RAM.
+  loki:
+    image: grafana/loki:3.7.2
+    container_name: <%= it.appName %>-loki
+    restart: unless-stopped
+    profiles: ["loki"]
+    networks: [<%= it.appName %>]
+    command: -config.file=/etc/loki/local-config.yaml
+    ports:
+      - "127.0.0.1:${LOKI_PORT:-3100}:3100"
+    volumes:
+      - loki-data:/loki
+    # PAS de healthcheck : image DISTROLESS (aucun shell dans le conteneur) — un
+    # healthcheck Docker la marquerait « unhealthy » à tort. Santé côté hôte :
+    # curl http://127.0.0.1:3100/ready
+
+  # --- Grafana (profile loki — visualisation des logs, datasource auto-provisionnée) ---
+  # Anonyme + rôle Admin pour un dev sans friction (JAMAIS en prod).
+  grafana:
+    image: grafana/grafana:latest
+    container_name: <%= it.appName %>-grafana
+    restart: unless-stopped
+    profiles: ["loki"]
+    networks: [<%= it.appName %>]
+    environment:
+      GF_AUTH_ANONYMOUS_ENABLED: "true"
+      GF_AUTH_ANONYMOUS_ORG_ROLE: Admin
+      GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_PASSWORD:-<%= it.appName %>-dev}
+      GF_ANALYTICS_REPORTING_ENABLED: "false"
+      GF_ANALYTICS_CHECK_FOR_UPDATES: "false"
+    ports:
+      - "127.0.0.1:${GRAFANA_PORT:-3000}:3000"
+    volumes:
+      - grafana-data:/var/lib/grafana
+      # Datasource Loki pré-câblée (lecture seule) → Grafana ouvre prêt, 0 setup.
+      - ./docker/grafana/provisioning:/etc/grafana/provisioning:ro
+    depends_on:
+      # service_started (pas healthy) : Loki est distroless, pas de healthcheck.
+      loki:
+        condition: service_started
+
+  # --- browser (profil browser — VOIR tes écrans, sans navigateur sur ta machine) ---
+  #
+  # Un navigateur jetable, piloté par un agent (ou par un script) : il ouvre une
+  # page, lit la CONSOLE, l'arbre d'ACCESSIBILITÉ et les REQUÊTES réelles, et
+  # dépose captures et journaux dans `tmp/browser/`. Sert à répondre « l'écran se
+  # monte-t-il et s'alimente-t-il ? » sans que quelqu'un ait à regarder pour toi.
+  #
+  # Pourquoi en conteneur plutôt que sur le poste : un navigateur automatisé lancé
+  # à nu peut saturer une machine de développement. Ici il est plafonné et meurt
+  # au `down`. Rien à installer non plus : ni Chromium, ni pilote.
+  #
+  # TROIS RÈGLES qui ne se devinent pas — sans elles la page reste blanche ou
+  # refusée, alors que le réseau, lui, passe :
+  #   1. Joindre ton app par `host.docker.internal`, JAMAIS `localhost` : dans un
+  #      conteneur ce nom désigne le conteneur lui-même. Si tu actives la barrière
+  #      Host (`domainCheck`), ajoute ce nom aux `trustedHosts` en développement —
+  #      sinon elle répond `421` alors que le réseau, lui, passe.
+  #   2. Passer par HTTPS : le cookie de session est `secure`, donc IGNORÉ sur une
+  #      origine `http://` qui n'est pas `localhost` — toutes les requêtes
+  #      authentifiées reviendraient en `401`, ce qui se lit à tort comme un échec
+  #      de connexion. Le certificat auto-signé de développement est accepté ici.
+  #   3. Rien à poser pour Vite : l'origine des assets se DÉRIVE du `Host` de la
+  #      requête. Arriver par `host.docker.internal` suffit — l'allowlist Vite et
+  #      le WebSocket du HMR suivent le même nom, et ton poste continue d'être
+  #      servi sur `127.0.0.1` en même temps. Pour forcer une origine unique
+  #      (proxy frontal), écris `publicOrigin` dans `nodefony.config.ts`.
+  #
+  # DEUX façons de s'en servir, et elles ne se valent pas :
+  #   - PILOTER directement — l'image embarque Chromium ET Playwright, on y copie
+  #     un script et on l'exécute (`docker cp … && docker exec … node …`). C'est
+  #     la voie normale : une commande, un JSON, un code de retour, quelques
+  #     secondes. Le devkit livre deux sondes prêtes (voir `AGENTS.md`), dont la
+  #     MESURE des contrastes et tailles réellement calculés par le moteur.
+  #   - EXPLORER par MCP — le conteneur est aussi un serveur MCP, joignable sur
+  #     `http://127.0.0.1:${BROWSER_PORT:-3001}/mcp` (il imprime la config à
+  #     coller dans ses journaux au démarrage). Utile pour fouiller une page à la
+  #     main ; plus lent et non scriptable pour tout le reste.
+  browser:
+    # Épinglée par empreinte : un `latest` mouvant sous un banc d'observation
+    # ferait varier le rendu sans qu'on le sache.
+    image: mcp/playwright@sha256:097d978439237cc9b12e10825836a97245add2be0479272cce9d98c368f024d1
+    container_name: <%= it.appName %>-browser
+    restart: unless-stopped
+    profiles: ["browser"]
+    networks: [<%= it.appName %>]
+    ports:
+      - "127.0.0.1:${BROWSER_PORT:-3001}:3000"
+    # L'ENTRYPOINT de l'image fixe déjà `--headless --browser chromium
+    # --no-sandbox` ; la commande le COMPLÈTE, elle ne le remplace pas.
+    command:
+      # Sans `--port`, le serveur parle en stdio : personne au bout d'un service.
+      - "--port=3000"
+      # Le défaut `localhost` ne serait pas joignable depuis l'hôte, même avec la
+      # publication de port ci-dessus.
+      - "--host=0.0.0.0"
+      # Le port n'est publié que sur 127.0.0.1 : la vérification d'hôte ferait
+      # doublon et refuserait l'accès par le nom du service.
+      - "--allowed-hosts=*"
+      # Certificat de développement auto-signé (cf règle 2 ci-dessus).
+      - "--ignore-https-errors"
+      # Captures, console et arbres écrits en FICHIERS dans le volume monté.
+      - "--output-dir=/output"
+      - "--output-mode=file"
+      # Profil en mémoire : rien sur le disque du conteneur, et un `down` efface
+      # l'état d'authentification avec lui.
+      - "--isolated"
+      # Un seul contexte pour tous les clients : une session ouverte reste ouverte
+      # d'un appel à l'autre. Ne survit pas à un `restart` (profil en mémoire).
+      - "--shared-browser-context"
+      - "--viewport-size=1440x900"
+    volumes:
+      # `tmp/` est ignoré par git — une capture est une PHOTO, jamais du versionné.
+      - ./tmp/browser:/output
+    # Le répertoire courant, pas seulement `--output-dir` : une capture demandée
+    # sous un nom relatif est résolue par Playwright contre le répertoire COURANT.
+    # Sans cette ligne elle reste dans le conteneur pendant que l'appel répond OK.
+    working_dir: /output
+    extra_hosts:
+      # Le nom par lequel le conteneur joint l'app qui tourne sur l'hôte.
+      - "host.docker.internal:host-gateway"
+    # Précaution : le `/dev/shm` par défaut de Docker (64 Mo) est connu pour faire
+    # mourir un onglet Chromium sans message sur une page lourde.
+    shm_size: "1gb"
+    # Bornes de ressources : c'est ce qui rend « jetable » vérifiable — un
+    # navigateur emballé ne peut pas prendre la machine, il se fait tuer.
+    deploy:
+      resources:
+        limits:
+          cpus: "2.0"
+          memory: 2g
+
+# Bridge nommé explicite : résolution DNS par nom de service, isolation des autres
+# projets compose, nettoyage propre au down. Pas de sous-réseau figé (anti-collision).
+networks:
+  <%= it.appName %>:
+    name: <%= it.appName %>-net
+    driver: bridge
+
+volumes:
+  redis-data:
+<% if (it.db) { %>  <%= it.db.service %>-data:
+<% } %>  redisinsight-data:
+  loki-data:
+  grafana-data:

package/templates/app/complete/deploy/migrate-job.yaml.tpl

@@ -0,0 +1,100 @@
+<% if (it.db) { %># <%= it.appName %> — migration du schéma AVANT le déploiement (Kubernetes)
+#
+# Ce fichier est rendu à TON nom : image, secret et libellés portent déjà
+# « <%= it.appName %> ». Il n'y a rien à recopier depuis une page de documentation.
+#
+# ── Pourquoi un travail séparé, et pas autre chose ───────────────────────────
+# Au démarrage, N exemplaires partent EN MÊME TEMPS : appliquer les migrations
+# depuis les pods, c'est N exécutions concurrentes, des privilèges de
+# modification du schéma dans le processus qui sert le trafic, et un
+# redémarrage en boucle généralisé si une migration échoue. Le verrou de
+# Nodefony rend ces variantes SÛRES — elles restent le mauvais endroit. Un
+# conteneur d'initialisation a le même défaut (une exécution par exemplaire).
+# Ici : UN travail, avant le déploiement, avec son propre compte.
+#
+# ── La règle dure ────────────────────────────────────────────────────────────
+# MÊME image et MÊME étiquette que le Deployment qui suit. Une migration jouée
+# depuis une autre version applique un schéma que le code déployé ne connaît
+# pas — et personne ne le voit avant la première requête.
+#
+# ── Le compte qui migre n'est pas le compte qui sert ─────────────────────────
+# `NF_MIGRATE_DATABASE_URL` remplace la connexion du connecteur POUR CETTE
+# COMMANDE SEULEMENT : le secret qui a le droit de modifier le schéma est monté
+# ici, et nulle part ailleurs. Elle doit désigner une connexion DIRECTE — un
+# répartiteur de connexions en mode transaction casse le verrou.
+#
+#   kubectl create secret generic <%= it.appName %>-db-migrator \
+#     --from-literal=url='<%= it.db.scheme %>://migrator:MOT_DE_PASSE@db:<%= it.db.port %>/<%= it.appName %>'
+#
+# ── Le déroulé ───────────────────────────────────────────────────────────────
+#   JOB=$(IMAGE_TAG=1.4.0 envsubst < deploy/migrate-job.yaml | kubectl create -f - -o name)
+#   kubectl wait --for=condition=complete --timeout=10m "$JOB" \
+#     || { kubectl logs "$JOB"; exit 1; }
+#   kubectl set image deployment/<%= it.appName %> <%= it.appName %>=<%= it.appName %>:1.4.0
+#
+# Le travail échoue → le déploiement n'a PAS lieu, l'ancienne version continue
+# de servir. Il réussit → les pods démarrent en `ddl: "none"` et leur sonde de
+# disponibilité les met en service dès que le schéma est à jour.
+#
+# Si tu as un chart Helm, ce même corps se pose en accroche :
+#   annotations: { "helm.sh/hook": pre-install,pre-upgrade }
+# En ArgoCD : `argocd.argoproj.io/hook: PreSync` + `sync-wave: "-1"`.
+#
+# Le pourquoi complet, les droits SQL exacts des deux comptes et la règle N-1
+# (compatibilité entre l'ancienne et la nouvelle version pendant le
+# remplacement) : `node_modules/@nodefony/drizzle/docs/migrations.md`.
+apiVersion: batch/v1
+kind: Job
+metadata:
+  # `generateName`, pas `name` : un Job est IMMUABLE. Un nom fixe fait échouer
+  # le second déploiement sur « existe déjà », et l'on croit à une panne de
+  # migration. Le nom réel est rendu par `kubectl create -o name`.
+  generateName: <%= it.appName %>-migrate-
+  labels:
+    app.kubernetes.io/name: <%= it.appName %>
+    app.kubernetes.io/component: migrate
+spec:
+  # Aucune reprise : une migration qui échoue laisse un état à comprendre, pas
+  # à rejouer en aveugle. Le travail est idempotent (rejouer n'applique rien),
+  # mais c'est une DÉCISION humaine, pas un réflexe de l'orchestrateur.
+  backoffLimit: 0
+  # Borne dure. Le délai d'attente de ton outil de déploiement doit rester
+  # AU-DESSUS, sinon il abandonne un travail qui, lui, tient toujours le verrou.
+  activeDeadlineSeconds: 600
+  # Le travail terminé s'efface seul — ses journaux restent le temps de les lire.
+  ttlSecondsAfterFinished: 3600
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: <%= it.appName %>
+        app.kubernetes.io/component: migrate
+    spec:
+      restartPolicy: Never
+      securityContext:
+        runAsNonRoot: true
+      containers:
+        - name: migrate
+          image: <%= it.appName %>:${IMAGE_TAG}
+          # Même forme que le `CMD` du Dockerfile : le binaire vit dans les
+          # `node_modules` de l'image, jamais dans le PATH.
+          command: ["node_modules/.bin/nodefony", "orm:migrate", "--json"]
+          env:
+            - name: NODE_ENV
+              value: production
+            - name: NF_MIGRATE_DATABASE_URL
+              valueFrom:
+                secretKeyRef:
+                  name: <%= it.appName %>-db-migrator
+                  key: url
+          resources:
+            requests:
+              cpu: 100m
+              memory: 128Mi
+            limits:
+              memory: 512Mi
+          securityContext:
+            allowPrivilegeEscalation: false
+            readOnlyRootFilesystem: false
+            capabilities:
+              drop: ["ALL"]
+<% } %>

package/templates/app/complete/docker/db/init-nodefony-e2e.sql.tpl

@@ -0,0 +1,30 @@
+<% if (it.db) { %>-- Les DEUX bases que la suite e2e de <%= it.appName %> exige, créées à
+-- l'initialisation du serveur.
+--
+-- Pourquoi elles ne se créent pas toutes seules au moment des tests : sur un
+-- moteur SERVEUR, `CREATE DATABASE` est un privilège d'administration que
+-- l'utilisateur applicatif n'a pas — et ne doit pas avoir. Une suite de tests
+-- ne fabrique donc pas sa base ; le décor la FOURNIT, ici comme en recette.
+-- (Sur SQLite il n'y a rien de tout ça : un fichier s'efface.)
+--
+--   <%= it.db.databaseE2e %>         → la base de la suite e2e, jamais celle du développement
+--   <%= it.db.databaseScratch %> → la base VIERGE que la suite de migrations salit puis remet à zéro
+--
+-- Du SQL, et pas un script shell : l'entrée d'initialisation EXÉCUTE un `.sh`
+-- dès qu'il porte le bit exécutable, et un montage qui ne le transmet pas fait
+-- mourir le serveur au démarrage (`bad interpreter`, code 126) — constaté. Un
+-- `.sql` est joué par le client, sans aucune question de permission.
+--
+-- ⚠️ Ce fichier n'est joué qu'à la PREMIÈRE initialisation du volume. Sur une
+-- infra déjà montée : `docker compose down -v` (PURGE les données), ou créer
+-- les deux bases à la main.
+<% if (it.db.choice === "postgres") { %>CREATE DATABASE "<%= it.db.databaseE2e %>" OWNER "<%= it.appName %>";
+CREATE DATABASE "<%= it.db.databaseScratch %>" OWNER "<%= it.appName %>";
+<% } else { %>-- L'utilisateur applicatif n'a de droits QUE sur sa base : les deux nouvelles
+-- lui sont accordées explicitement, sinon il ne pourrait pas y créer ses tables.
+CREATE DATABASE IF NOT EXISTS `<%= it.db.databaseE2e %>`;
+CREATE DATABASE IF NOT EXISTS `<%= it.db.databaseScratch %>`;
+GRANT ALL PRIVILEGES ON `<%= it.db.databaseE2e %>`.* TO '<%= it.appName %>'@'%';
+GRANT ALL PRIVILEGES ON `<%= it.db.databaseScratch %>`.* TO '<%= it.appName %>'@'%';
+FLUSH PRIVILEGES;
+<% } %><% } %>

package/templates/app/complete/docker/grafana/provisioning/datasources/loki.yaml.tpl

@@ -0,0 +1,15 @@
+# Datasource Loki auto-provisionnée pour Grafana (dev) — montée en lecture seule par
+# le compose (./docker/grafana/provisioning:/etc/grafana/provisioning:ro). Pointe le
+# service `loki` via le DNS INTERNE du réseau <%= it.appName %>-net (conteneur→conteneur),
+# JAMAIS localhost. Grafana ouvre donc directement sur Loki, 0 configuration manuelle.
+apiVersion: 1
+datasources:
+  - name: Loki
+    type: loki
+    access: proxy
+    uid: <%= it.appName %>-loki
+    url: http://loki:3100
+    isDefault: true
+    editable: true
+    jsonData:
+      maxLines: 1000

package/templates/app/complete/env.local.tpl

@@ -0,0 +1,11 @@
+# ══════════════════════════════════════════════════════════════════════════
+#  Secrets & valeurs MACHINE de <%= it.appName %> — GITIGNORÉ (règle *.local)
+# ══════════════════════════════════════════════════════════════════════════
+# Généré par `nodefony create app`. Ne JAMAIS committer ce fichier ; en
+# production les secrets viennent du secret-manager (Secret k8s, vault…).
+# Rotation / rattrapage : npx nodefony security:secrets --write
+
+# Clés de chiffrement au repos (32 octets aléatoires, base64) :
+<%= Object.entries(it.secrets).map(([k, v]) => k + "=" + v).join("\n") + "\n" %>
+# Compte admin local : admin / admin par défaut — décommente pour changer :
+# NF_ADMIN_PASSWORD=change-me