@apc-projects/elysia-cli 0.1.0 → 0.1.1

package/README.md

@@ -1,12 +1,13 @@
 # @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).
+[![npm](https://img.shields.io/npm/v/@apc-projects/elysia-cli.svg)](https://www.npmjs.com/package/@apc-projects/elysia-cli)
+[![license](https://img.shields.io/npm/l/@apc-projects/elysia-cli.svg)](./LICENSE)
 
-## Prérequis
+CLI de scaffolding pour projets **ElysiaJS**. Génère modules, services, models et macros, et branche automatiquement les plugins dans l'application via manipulation d'AST (ts-morph).
 
-Ce CLI est **Bun-only** : le binaire s'exécute avec Bun (le `bin` pointe sur du TypeScript). Node/`npx` n'est pas supporté.
+## Prérequis
 
-Installe Bun si ce n'est pas déjà fait :
+Bun — le CLI s'exécute avec Bun ; Node / `npx` n'est pas supporté.
 
 ```bash
 # macOS / Linux
@@ -16,118 +17,68 @@ curl -fsSL https://bun.sh/install | bash
 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 :
+## Installation
 
 ```bash
+# via npm
 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>
+# ou depuis GitHub, en global
+bun add -g github:<owner>/elysia-cli
 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 init <project>           # bun create elysia + structure elysia-cli
+elysia-cli generate module <name>   # alias : g
 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
+elysia-cli macro <name>             # génère une macro + .use()
+elysia-cli add <plugin>             # cors | openapi | jwt | logger | better-auth | prisma
 ```
 
-`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`).
+### Plugins (`add`)
 
-`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`.
+Les dépendances sont installées automatiquement (`--no-install` pour désactiver).
 
-`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).
+| Plugin | Effet |
+| --- | --- |
+| `cors`, `jwt` | Branchés dans l'app via `.use(...)`. |
+| `openapi` | Monté hors production uniquement. Intègre le schéma OpenAPI de better-auth s'il est présent. |
+| `logger` | Logger applicatif (chalk) dans `src/utils/logger.ts`, hooks de logging des requêtes, et bascule des `console.*` vers `Logger`. |
+| `prisma` | Prisma 7 : client singleton avec driver adapter, `schema.prisma` (+ générateur prismabox), `prisma.config.ts`, `DATABASE_URL` dans `.env.local`, scripts `prebuild`/`prestart`. Provider au choix (PostgreSQL / MySQL-MariaDB / SQLite). |
+| `better-auth` | `src/lib/auth.ts` + macro `auth` (`.use(authMacro)`, routes sur `/api/auth`), secret et URL dans `.env.local`. Câble l'adapter Prisma et les migrations si Prisma est présent. |
 
-Exemple :
+## Structure générée
 
-```bash
-elysia-cli g module user
-```
-
-Génère :
+`generate module user` crée un module feature-based, branché dans l'agrégateur `src/modules/index.ts` :
 
 ```
 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é
+  user.controller.ts   # instance Elysia « user »
+  user.service.ts      # classe « User »
+  user.model.ts        # schémas « UserModel » + 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)`.
+Un projet complet (`init` + `prisma`, `better-auth`, `logger`, `openapi`) ressemble à :
+
+```
+mon-api/
+  prisma/schema.prisma
+  prisma.config.ts
+  src/
+    index.ts               # app Elysia (hooks logger, .use(modules), .use(authMacro)…)
+    modules/index.ts       # agrégateur des modules
+    lib/auth.ts            # instance better-auth
+    macros/auth.macro.ts   # macro « auth »
+    db/index.ts            # client Prisma
+    utils/logger.ts
+  .env.local               # DATABASE_URL, BETTER_AUTH_SECRET, BETTER_AUTH_URL
+  elysia-cli.config.json
+```
 
 ## Configuration
 
@@ -138,32 +89,19 @@ Optionnel — `elysia-cli.config.json` à la racine du projet cible :
   "srcDir": "src",
   "modulesDir": "src/modules",
   "appEntry": "src/index.ts",
-  "appVariable": "app"
+  "appVariable": "app",
+  "modulesEntry": "src/modules/index.ts",
+  "modulesVariable": "modules"
 }
 ```
 
-## Structure du package
+## Développement
 
+```bash
+bun install
+bun run dev -- --help    # exécute src/index.ts
+bun run build            # binaire standalone -> dist/elysia-cli
 ```
-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
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apc-projects/elysia-cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Générateur de scaffolding pour projets ElysiaJS (modules, services, models, plugins).",
   "type": "module",
   "license": "MIT",
@@ -10,7 +10,14 @@
     "type": "git",
     "url": "git+https://github.com/Segu27/elysia-cli.git"
   },
-  "keywords": ["elysia", "elysiajs", "cli", "scaffolding", "bun", "generator"],
+  "keywords": [
+    "elysia",
+    "elysiajs",
+    "cli",
+    "scaffolding",
+    "bun",
+    "generator"
+  ],
   "bin": {
     "elysia-cli": "./src/index.ts"
   },