@apc-projects/elysia-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Segu27
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,170 @@
+# @apc-projects/elysia-cli
+
+CLI de scaffolding pour projets **ElysiaJS**. Génère des modules (controller + service + model + plugin) suivant les bonnes pratiques Elysia, et **branche automatiquement** le plugin dans ton application via manipulation d'AST (ts-morph).
+
+## Prérequis
+
+Ce CLI est **Bun-only** : le binaire s'exécute avec Bun (le `bin` pointe sur du TypeScript). Node/`npx` n'est pas supporté.
+
+Installe Bun si ce n'est pas déjà fait :
+
+```bash
+# macOS / Linux
+curl -fsSL https://bun.sh/install | bash
+
+# Windows (PowerShell)
+powershell -c "irm bun.sh/install.ps1 | iex"
+```
+
+Vérifie l'installation :
+
+```bash
+bun --version
+```
+
+## Stack
+
+- **Bun** — runtime (exécute le TypeScript directement, pas de build en dev)
+- **commander** — parsing des commandes
+- **@clack/prompts** — prompts interactifs
+- **chalk** — sortie colorée
+- **ts-morph** — lecture/écriture de l'AST TypeScript (injection du `.use()`)
+
+## Installation (dev)
+
+```bash
+bun install
+bun run dev -- --help       # exécute src/index.ts directement (aucun build)
+```
+
+Pour l'utiliser comme binaire global pendant le dev :
+
+```bash
+bun link                    # dans ce package
+cd ../mon-api-test
+bun link @apc-projects/elysia-cli    # dans le projet cible
+elysia-cli --help
+```
+
+Le `bin` pointe sur `src/index.ts` (shebang `#!/usr/bin/env bun`) : Bun lit le TS, donc rien à compiler pour l'installer. Un `bun install` du package suffit.
+
+## Build standalone (distribution)
+
+```bash
+bun run build               # bun build --compile -> dist/elysia-cli
+./dist/elysia-cli --help    # exécutable autonome, sans Bun ni Node
+```
+
+## Utilisation sans cloner le dépôt
+
+### Via npm (recommandé)
+
+Après publication sur npm (`bun publish` / `npm publish` — le package est `@apc-projects/elysia-cli`), on peut l'exécuter sans installation :
+
+```bash
+bunx @apc-projects/elysia-cli init mon-api
+bunx @apc-projects/elysia-cli add prisma
+```
+
+`bunx` résout le **nom du package** (pas le nom du binaire), d'où `@apc-projects/elysia-cli`. Les dépendances sont installées automatiquement au premier run puis mises en cache.
+
+### Via GitHub (sans publier sur npm)
+
+Bun sait installer depuis un dépôt Git. En dépendance de projet :
+
+```bash
+bun add github:<owner>/<repo>        # ajoute @apc-projects/elysia-cli au projet
+bunx elysia-cli init mon-api         # le binaire local est alors résolu
+```
+
+Ou en global :
+
+```bash
+bun add -g github:<owner>/<repo>
+elysia-cli init mon-api
+```
+
+Comme le `bin` pointe sur `src/index.ts` (shebang `#!/usr/bin/env bun`), aucune étape de build n'est requise à l'installation — Bun exécute le TypeScript directement. Assure-toi que `files` inclut `src` (c'est le cas) pour que la source soit bien livrée.
+
+> Note : `bunx github:<owner>/<repo>` en une commande n'est pas garanti — passe par `bun add` (projet ou global) pour la voie GitHub. Pour un `bunx <nom>` direct, publie sur npm.
+
+## Commandes
+
+```bash
+elysia-cli generate module <name>     # alias: g module
+elysia-cli generate service <name>
+elysia-cli generate model <name>
+elysia-cli macro <name>               # génère src/macros/<name>.macro.ts + .use()
+elysia-cli add <plugin>               # cors | openapi | jwt | logger | better-auth | prisma
+elysia-cli init <project-name>        # `bun create elysia` + couche elysia-cli
+```
+
+`add` installe automatiquement les dépendances (`bun add`, désactivable avec `--no-install`) :
+
+- `cors`, `jwt` — branchés par `.use(...)` dans l'app entry.
+- `openapi` — branché **uniquement hors production** (`NODE_ENV !== "production"`). Si **better-auth** est présent, le schéma OpenAPI de better-auth est intégré à la doc (`documentation.components` / `documentation.paths`). L'intégration marche dans les deux sens : si tu ajoutes `openapi` puis `better-auth`, ce dernier **re-patche** l'appel `openapi()` existant pour y injecter la doc auth.
+- `logger` — scaffolde le logger applicatif (chalk) dans `src/utils/logger.ts`, injecte les hooks `onBeforeHandle`/`onAfterResponse` **directement dans la chaîne** de `src/index.ts`, et remplace les `console.*` par le `Logger`.
+- `prisma` — Prisma 7. **Demande le provider** (PostgreSQL / MySQL-MariaDB / SQLite) et l'**URL de connexion**, puis scaffolde le client singleton avec le bon driver adapter (`src/db/index.ts`), `prisma/schema.prisma` (provider choisi, sans `url`, + générateur **prismabox** pour les modèles de validation Elysia), `prisma.config.ts` (URL pour Migrate), et ajoute `DATABASE_URL` à `.env.local`. Le client est généré vers un **output custom** (`src/generated/prisma`, Prisma 7) et importé depuis `../generated/prisma/client` dans `src/db/index.ts` — jamais depuis `@prisma/client`. Le dossier `src/generated` est git-ignoré (régénéré via `prebuild`/post-install). `prisma generate` est lancé après install. Ajoute aussi au `package.json` (sans écraser l'existant) les scripts `build`/`start` s'ils manquent, plus `prebuild` (`prisma generate`) et `prestart` (`prisma migrate deploy`). Les paquets (`@prisma/adapter-*`, driver natif) dépendent du provider.
+- `better-auth` — scaffolde `src/lib/auth.ts` **et une macro `auth`** (`src/macros/auth.macro.ts`) qui monte le handler (routes sur `/api/auth`) et expose `user`/`session` aux routes protégées via `{ auth: true }` ; branché par `.use(authMacro)`. **Demande `BETTER_AUTH_URL`** et ajoute `BETTER_AUTH_SECRET` (généré) + `BETTER_AUTH_URL` à `.env.local`. **Si Prisma est présent** (ou ajouté en même temps), l'adapter Prisma est câblé avec le provider détecté depuis le schéma, et les migrations auth sont générées puis appliquées (`@better-auth/cli generate` + `prisma migrate`).
+
+`generate module` branche chaque controller dans l'agrégateur `src/modules/index.ts` (créé au besoin, avec `.use(modules)` dans l'app entry), et non plus directement dans `src/index.ts`.
+
+`init` déplace la route racine par défaut dans `src/modules/index.ts` et propose de sélectionner des plugins à ajouter tout de suite (install auto).
+
+Exemple :
+
+```bash
+elysia-cli g module user
+```
+
+Génère :
+
+```
+src/modules/user/
+  user.controller.ts   # instance Elysia `user` (routes, body/response = UserModel)
+  user.service.ts      # classe abstraite `User` (logique métier)
+  user.model.ts        # objet de schémas `UserModel` (t.*) + type TS dérivé
+  index.ts             # barrel export
+```
+
+Le controller s'exporte sous le nom du module (`export const user = …`), le service est une classe `User`, et le model est un objet de schémas (`UserModel.create`, `UserModel.entity`, `UserModel.update`) avec un type TypeScript dérivé — comme dans la doc Elysia. Le controller est ensuite branché dans l'agrégateur `src/modules/index.ts` via `.use(user)`.
+
+## Configuration
+
+Optionnel — `elysia-cli.config.json` à la racine du projet cible :
+
+```json
+{
+  "srcDir": "src",
+  "modulesDir": "src/modules",
+  "appEntry": "src/index.ts",
+  "appVariable": "app"
+}
+```
+
+## Structure du package
+
+```
+src/
+  index.ts              # entrée commander
+  commands/
+    generate.ts         # generate module/service/model
+    add.ts              # add <plugin>
+    init.ts             # init <project>
+  utils/
+    logger.ts           # wrappers chalk + clack
+    naming.ts           # helpers de casse (pascal, camel, kebab)
+    project.ts          # chargement du Project ts-morph + config
+    inject.ts           # injection du .use() dans l'app
+  templates.ts          # fonctions de génération de contenu
+```
+
+> Note : `tsup.config.ts` n'est plus utilisé (build géré par `bun build --compile`) et peut être supprimé.
+
+## Étendre
+
+Ajoute un générateur : nouvelle fonction dans `templates.ts` + branche-la dans `commands/generate.ts`. Pour un nouveau type d'injection, réutilise `utils/inject.ts` (basé sur ts-morph, donc robuste aux reformats).
+
+## Licence
+
+[MIT](./LICENSE) © Segu27

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@apc-projects/elysia-cli",
+  "version": "0.1.0",
+  "description": "Générateur de scaffolding pour projets ElysiaJS (modules, services, models, plugins).",
+  "type": "module",
+  "license": "MIT",
+  "author": "Segu27",
+  "homepage": "https://github.com/Segu27/elysia-cli#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Segu27/elysia-cli.git"
+  },
+  "keywords": ["elysia", "elysiajs", "cli", "scaffolding", "bun", "generator"],
+  "bin": {
+    "elysia-cli": "./src/index.ts"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "bun src/index.ts",
+    "start": "bun src/index.ts",
+    "build": "bun build src/index.ts --compile --outfile dist/elysia-cli",
+    "typecheck": "tsc --noEmit"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.7.0",
+    "chalk": "^5.6.2",
+    "commander": "^12.1.0",
+    "ts-morph": "^23.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "@types/bun": "^1.1.0",
+    "@types/node": "^20.19.43"
+  }
+}

package/src/commands/add.ts

@@ -0,0 +1,362 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join, dirname, relative } from "node:path";
+import { randomBytes } from "node:crypto";
+import type { Command } from "commander";
+import * as p from "@clack/prompts";
+import { loadConfig, loadTsProject, type ElysiaCliConfig } from "../utils/project.js";
+import {
+  registerUse,
+  appendChain,
+  moduleSpecifierFrom,
+  replaceConsoleWithLogger,
+  patchOpenapiWithAuth,
+} from "../utils/inject.js";
+import { installDeps, run } from "../utils/pm.js";
+import { ensureEnvVars } from "../utils/env.js";
+import { ensureGitignore } from "../utils/gitignore.js";
+import { ensureScripts } from "../utils/package-json.js";
+import {
+  DB_PROVIDERS,
+  DB_PROVIDER_KEYS,
+  detectPrismaProvider,
+  type DbProvider,
+} from "../utils/db.js";
+import { log, CliError } from "../utils/logger.js";
+import {
+  loggerTemplate,
+  loggerHooksSegment,
+  authLibTemplate,
+  authMacroTemplate,
+  prismaClientTemplate,
+  prismaSchemaTemplate,
+  prismaConfigTemplate,
+} from "../templates.js";
+
+type PostInstall = () => void;
+
+interface PresetOutcome {
+  pkgs?: string[];
+  devPkgs?: string[];
+  postInstall?: PostInstall;
+}
+
+interface Preset {
+  /** Dépendances de base (toujours installées). */
+  pkgs?: string[];
+  devPkgs?: string[];
+  /** Scaffolding + injection. Async pour permettre des prompts. */
+  apply: (config: ElysiaCliConfig) => Promise<PresetOutcome> | PresetOutcome | void;
+}
+
+export interface ApplyResult {
+  pkgs: string[];
+  devPkgs: string[];
+  postInstall?: PostInstall;
+}
+
+/** Preset middleware simple : `.use(<expr>)` + import + dépendance. */
+function usePreset(spec: {
+  expr: string;
+  importName: string;
+  importFrom: string;
+}): Preset {
+  return {
+    pkgs: [spec.importFrom],
+    apply: (config) => {
+      const project = loadTsProject();
+      registerUse(
+        project,
+        { entry: config.appEntry, variable: config.appVariable },
+        {
+          useExpr: spec.expr,
+          ensureImport: { names: [spec.importName], moduleSpecifier: spec.importFrom },
+        },
+      );
+    },
+  };
+}
+
+/** Prisma déjà présent dans le projet ? (schéma ou client généré). */
+function hasPrisma(config: ElysiaCliConfig): boolean {
+  return (
+    existsSync(join(process.cwd(), "prisma", "schema.prisma")) ||
+    existsSync(join(process.cwd(), config.srcDir, "db", "index.ts"))
+  );
+}
+
+async function promptProvider(): Promise<string> {
+  const answer = await p.select({
+    message: "Provider de base de données ?",
+    options: DB_PROVIDER_KEYS.map((k) => ({
+      value: k,
+      label: DB_PROVIDERS[k].label,
+    })),
+    initialValue: "postgresql",
+  });
+  if (p.isCancel(answer)) throw new CliError("Annulé.");
+  return answer as string;
+}
+
+async function promptText(message: string, initial: string): Promise<string> {
+  const answer = await p.text({ message, placeholder: initial, defaultValue: initial });
+  if (p.isCancel(answer)) throw new CliError("Annulé.");
+  return (answer as string) || initial;
+}
+
+async function promptPassword(message: string): Promise<string> {
+  const answer = await p.password({ message });
+  if (p.isCancel(answer)) throw new CliError("Annulé.");
+  return (answer as string) ?? "";
+}
+
+/** Demande les composants de connexion et construit l'URL selon le provider. */
+async function promptDatabaseUrl(provider: DbProvider): Promise<string> {
+  if (provider.isFile || !provider.buildUrl) {
+    return promptText("Chemin du fichier SQLite", provider.defaultUrl);
+  }
+  const host = await promptText("Host", "localhost");
+  const port = await promptText("Port", provider.defaultPort ?? "");
+  const user = await promptText("Utilisateur", "user");
+  const password = await promptPassword("Mot de passe");
+  const database = await promptText("Base de données", "mydb");
+  return provider.buildUrl({ host, port, user, password, database });
+}
+
+/** better-auth déjà présent dans le projet ? */
+function hasBetterAuth(config: ElysiaCliConfig): boolean {
+  return existsSync(join(process.cwd(), config.srcDir, "lib", "auth.ts"));
+}
+
+// L'ordre compte : prisma avant better-auth, et better-auth avant openapi
+// (pour intégrer le schéma auth dans la doc).
+const PLUGINS: Record<string, Preset> = {
+  cors: usePreset({ expr: "cors()", importName: "cors", importFrom: "@elysiajs/cors" }),
+  jwt: usePreset({
+    expr: 'jwt({ name: "jwt", secret: process.env.JWT_SECRET! })',
+    importName: "jwt",
+    importFrom: "@elysiajs/jwt",
+  }),
+  logger: {
+    pkgs: ["chalk"],
+    apply: (config) => {
+      scaffoldFile(join(config.srcDir, "utils", "logger.ts"), loggerTemplate());
+      const project = loadTsProject();
+      const app = { entry: config.appEntry, variable: config.appVariable };
+      const loggerPath = join(config.srcDir, "utils", "logger");
+      appendChain(project, app, loggerHooksSegment(), {
+        dedupe: "Logger.app.request",
+        ensureImports: [
+          {
+            names: ["Logger"],
+            moduleSpecifier: moduleSpecifierFrom(config.appEntry, loggerPath),
+          },
+        ],
+      });
+      replaceConsoleWithLogger(project, app, loggerPath);
+    },
+  },
+  prisma: {
+    pkgs: ["@prisma/client"],
+    devPkgs: ["prisma", "prismabox", "dotenv"],
+    apply: async (config) => {
+      const provider = DB_PROVIDERS[await promptProvider()];
+      const url = await promptDatabaseUrl(provider);
+
+      scaffoldFile("prisma.config.ts", prismaConfigTemplate());
+      scaffoldFile(
+        join("prisma", "schema.prisma"),
+        prismaSchemaTemplate(provider.prismaProvider),
+      );
+      scaffoldFile(join(config.srcDir, "db", "index.ts"), prismaClientTemplate(provider));
+      ensureEnvVars({ DATABASE_URL: `"${url}"` });
+      // Le client Prisma est généré (rebuild via prebuild/postInstall) : on l'ignore.
+      ensureGitignore(["src/generated"]);
+      // Ajoute build/start s'ils manquent, puis les hooks pre* correspondants :
+      // prisma generate avant le build, prisma migrate deploy avant le start.
+      ensureScripts({
+        build: `bun build ${config.appEntry} --target bun --outdir dist`,
+        start: `bun ${config.appEntry}`,
+        prebuild: "prisma generate",
+        prestart: "prisma migrate deploy",
+      });
+
+      return {
+        pkgs: [provider.adapterPkg, ...provider.driverPkgs],
+        postInstall: () => {
+          run("prisma generate", "bunx", ["prisma", "generate"]);
+        },
+      };
+    },
+  },
+  "better-auth": {
+    pkgs: ["better-auth"],
+    apply: async (config) => {
+      const withPrisma = hasPrisma(config);
+      const provider = detectPrismaProvider() ?? "postgresql";
+
+      scaffoldFile(
+        join(config.srcDir, "lib", "auth.ts"),
+        authLibTemplate(withPrisma, provider),
+      );
+      // Macro `auth` : monte le handler + expose user/session aux routes.
+      scaffoldFile(
+        join(config.srcDir, "macros", "auth.macro.ts"),
+        authMacroTemplate(),
+      );
+
+      const project = loadTsProject();
+      registerUse(
+        project,
+        { entry: config.appEntry, variable: config.appVariable },
+        {
+          useExpr: "authMacro",
+          ensureImport: {
+            names: ["authMacro"],
+            moduleSpecifier: moduleSpecifierFrom(
+              config.appEntry,
+              join(config.srcDir, "macros", "auth.macro"),
+            ),
+          },
+        },
+      );
+
+      // Si un openapi a déjà été injecté, on le re-patche avec la doc auth.
+      patchOpenapiWithAuth(
+        project,
+        config.appEntry,
+        join(config.srcDir, "lib", "auth"),
+      );
+
+      const baseUrl = await promptText(
+        "URL de l'app (BETTER_AUTH_URL)",
+        "http://localhost:3000",
+      );
+      ensureEnvVars({
+        BETTER_AUTH_SECRET: `"${randomBytes(32).toString("hex")}"`,
+        BETTER_AUTH_URL: `"${baseUrl}"`,
+      });
+
+      log.info("better-auth monté sur /api/auth.");
+
+      if (!withPrisma) return {};
+      return {
+        postInstall: () => {
+          // Le client Prisma (output custom) doit exister avant que
+          // `better-auth generate` ne lise src/db.
+          run("prisma generate", "bunx", ["prisma", "generate"]);
+          const generated = run("better-auth generate", "bunx", [
+            "@better-auth/cli",
+            "generate",
+            "--y",
+          ]);
+          if (generated) {
+            run("prisma migrate", "bunx", [
+              "prisma",
+              "migrate",
+              "dev",
+              "--name",
+              "add-auth",
+            ]);
+          }
+        },
+      };
+    },
+  },
+  openapi: {
+    pkgs: ["@elysiajs/openapi"],
+    apply: (config) => {
+      const project = loadTsProject();
+      const app = { entry: config.appEntry, variable: config.appVariable };
+      const withAuth = hasBetterAuth(config);
+
+      // Avec better-auth : intègre le schéma auth dans la doc OpenAPI.
+      const expr = withAuth
+        ? "openapi({ enabled : process.env.NODE_ENV !== \"production\", documentation: { components: await OpenAPI.components, paths: await OpenAPI.getPaths() } })"
+        : "openapi({ enabled : process.env.NODE_ENV !== \"production\" })";
+
+      const ensureImports = [
+        { names: ["openapi"], moduleSpecifier: "@elysiajs/openapi" },
+      ];
+      if (withAuth) {
+        ensureImports.push({
+          names: ["OpenAPI"],
+          moduleSpecifier: moduleSpecifierFrom(
+            config.appEntry,
+            join(config.srcDir, "lib", "auth"),
+          ),
+        });
+      }
+
+      appendChain(project, app, `.use(${expr})`, {
+        dedupe: "openapi(",
+        ensureImports,
+      });
+    },
+  },
+};
+
+export const PLUGIN_KEYS = Object.keys(PLUGINS);
+
+/** Applique un preset. N'installe PAS (l'appelant regroupe deps + post-install). */
+export async function applyPlugin(
+  key: string,
+  config: ElysiaCliConfig,
+): Promise<ApplyResult> {
+  const preset = PLUGINS[key];
+  if (!preset) {
+    throw new CliError(
+      `Plugin inconnu "${key}". Disponibles : ${PLUGIN_KEYS.join(", ")}.`,
+    );
+  }
+  const res: PresetOutcome = (await preset.apply(config)) ?? {};
+  return {
+    pkgs: [...(preset.pkgs ?? []), ...(res.pkgs ?? [])],
+    devPkgs: [...(preset.devPkgs ?? []), ...(res.devPkgs ?? [])],
+    postInstall: res.postInstall,
+  };
+}
+
+function scaffoldFile(relPath: string, content: string): void {
+  const target = join(process.cwd(), relPath);
+  if (existsSync(target)) {
+    log.skipped(relPath);
+    return;
+  }
+  mkdirSync(dirname(target), { recursive: true });
+  writeFileSync(target, content, "utf8");
+  log.created(relative(process.cwd(), target));
+}
+
+export function registerAddCommand(program: Command) {
+  program
+    .command("add")
+    .description(`Ajoute un plugin/preset (${PLUGIN_KEYS.join(", ")})`)
+    .argument("[plugin]", PLUGIN_KEYS.join(" | "))
+    .option("--no-install", "ne pas installer ni exécuter les post-install")
+    .action(async (plugin?: string, opts?: { install: boolean }) => {
+      let key = plugin;
+      if (!key) {
+        const answer = await p.select({
+          message: "Quel plugin ajouter ?",
+          options: PLUGIN_KEYS.map((v) => ({ value: v, label: v })),
+        });
+        if (p.isCancel(answer)) throw new CliError("Annulé.");
+        key = answer as string;
+      }
+
+      const config = loadConfig();
+      const { pkgs, devPkgs, postInstall } = await applyPlugin(key, config);
+
+      if (opts?.install ?? true) {
+        installDeps(pkgs);
+        installDeps(devPkgs, { dev: true });
+        postInstall?.();
+      } else {
+        if (pkgs.length) log.info(`À installer : bun add ${pkgs.join(" ")}`);
+        if (devPkgs.length) log.info(`À installer : bun add -d ${devPkgs.join(" ")}`);
+        if (postInstall) log.info("Étapes post-install à lancer manuellement.");
+      }
+
+      log.success(`Plugin ${key} ajouté.`);
+    });
+}