@apc-projects/elysia-cli 0.1.0

package/src/commands/generate.ts

@@ -0,0 +1,173 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join, relative, resolve, dirname } from "node:path";
+import type { Command } from "commander";
+import * as p from "@clack/prompts";
+import type { Project } from "ts-morph";
+import {
+  buildNames,
+  nameError,
+  assertValidName,
+  type NameSet,
+} from "../utils/naming.js";
+import {
+  loadConfig,
+  loadTsProject,
+  moduleDir,
+  type ElysiaCliConfig,
+} from "../utils/project.js";
+import { registerUse, moduleSpecifierFrom } from "../utils/inject.js";
+import { log, CliError } from "../utils/logger.js";
+import {
+  controllerTemplate,
+  serviceTemplate,
+  modelTemplate,
+  barrelTemplate,
+  modulesIndexTemplate,
+} from "../templates.js";
+
+type Kind = "module" | "service" | "model";
+const KINDS: Kind[] = ["module", "service", "model"];
+
+export function registerGenerateCommand(program: Command) {
+  program
+    .command("generate")
+    .alias("g")
+    .description("Génère un module, service ou model Elysia")
+    .argument("[kind]", "module | service | model")
+    .argument("[name]", "nom (ex: user, user-profile)")
+    .option("--no-register", "ne pas injecter le .use() dans l'app entry")
+    .action(async (kind?: string, name?: string, opts?: { register: boolean }) => {
+      const resolved = await resolveArgs(kind, name);
+      const names = buildNames(resolved.name);
+      const config = loadConfig();
+
+      switch (resolved.kind) {
+        case "module":
+          generateModule(names, config, opts?.register ?? true);
+          break;
+        case "service":
+          writeSingle(config, names, "service", serviceTemplate(names));
+          break;
+        case "model":
+          writeSingle(config, names, "model", modelTemplate(names));
+          break;
+      }
+    });
+}
+
+async function resolveArgs(
+  kind?: string,
+  name?: string,
+): Promise<{ kind: Kind; name: string }> {
+  let k = kind as Kind | undefined;
+  if (!k) {
+    const answer = await p.select({
+      message: "Que veux-tu générer ?",
+      options: KINDS.map((v) => ({ value: v, label: v })),
+    });
+    if (p.isCancel(answer)) throw new CliError("Annulé.");
+    k = answer as Kind;
+  }
+  if (!KINDS.includes(k)) {
+    throw new CliError(`Type inconnu "${k}". Attendu : ${KINDS.join(", ")}.`);
+  }
+
+  let n = name;
+  if (!n) {
+    const answer = await p.text({
+      message: `Nom du ${k} ?`,
+      placeholder: "user",
+      validate: nameError,
+    });
+    if (p.isCancel(answer)) throw new CliError("Annulé.");
+    n = answer as string;
+  }
+  assertValidName(n);
+  return { kind: k, name: n };
+}
+
+function generateModule(names: NameSet, config: ReturnType<typeof loadConfig>, register: boolean) {
+  const dir = moduleDir(config, names.kebab);
+  log.title(`Génération du module ${names.pascal}`);
+
+  const files: Array<[string, string]> = [
+    [`${names.kebab}.controller.ts`, controllerTemplate(names)],
+    [`${names.kebab}.service.ts`, serviceTemplate(names)],
+    [`${names.kebab}.model.ts`, modelTemplate(names)],
+    ["index.ts", barrelTemplate(names)],
+  ];
+
+  mkdirSync(dir, { recursive: true });
+  for (const [file, content] of files) {
+    const full = join(dir, file);
+    if (existsSync(full)) {
+      log.skipped(relative(process.cwd(), full));
+      continue;
+    }
+    writeFileSync(full, content, "utf8");
+    log.created(relative(process.cwd(), full));
+  }
+
+  if (register) {
+    const project = loadTsProject();
+    ensureModulesAggregator(project, config);
+
+    const importPath = join(config.modulesDir, names.kebab); // dossier => index barrel
+    const controllerVar = names.camel;
+    registerUse(
+      project,
+      { entry: config.modulesEntry, variable: config.modulesVariable },
+      {
+        useExpr: controllerVar,
+        ensureImport: {
+          names: [controllerVar],
+          moduleSpecifier: moduleSpecifierFrom(config.modulesEntry, importPath),
+        },
+      },
+    );
+  }
+
+  log.success(`Module ${names.pascal} prêt.`);
+}
+
+function writeSingle(
+  config: ReturnType<typeof loadConfig>,
+  names: NameSet,
+  kind: "service" | "model",
+  content: string,
+) {
+  const dir = moduleDir(config, names.kebab);
+  mkdirSync(dir, { recursive: true });
+  const full = join(dir, `${names.kebab}.${kind}.ts`);
+  if (existsSync(full)) {
+    throw new CliError(`${relative(process.cwd(), full)} existe déjà.`);
+  }
+  writeFileSync(full, content, "utf8");
+  log.created(relative(process.cwd(), full));
+  log.success(`${kind} ${names.pascal} généré.`);
+}
+
+/**
+ * Garantit l'existence de l'agrégateur `src/modules/index.ts` : s'il manque, le
+ * crée (instance `modules` vide) et le branche dans l'app entry via `.use(modules)`.
+ */
+function ensureModulesAggregator(project: Project, config: ElysiaCliConfig): void {
+  const abs = resolve(process.cwd(), config.modulesEntry);
+  if (existsSync(abs)) return;
+
+  mkdirSync(dirname(abs), { recursive: true });
+  writeFileSync(abs, modulesIndexTemplate(), "utf8");
+  log.created(relative(process.cwd(), abs));
+
+  registerUse(
+    project,
+    { entry: config.appEntry, variable: config.appVariable },
+    {
+      useExpr: config.modulesVariable,
+      ensureImport: {
+        names: [config.modulesVariable],
+        moduleSpecifier: moduleSpecifierFrom(config.appEntry, config.modulesDir),
+      },
+    },
+  );
+}

package/src/commands/init.ts

@@ -0,0 +1,158 @@
+import { existsSync, mkdirSync, writeFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import type { Command } from "commander";
+import * as p from "@clack/prompts";
+import { loadTsProject, type ElysiaCliConfig } from "../utils/project.js";
+import {
+  removeRootRoute,
+  registerUse,
+  moduleSpecifierFrom,
+} from "../utils/inject.js";
+import { nameError, assertValidName } from "../utils/naming.js";
+import { modulesIndexTemplate } from "../templates.js";
+import { applyPlugin, PLUGIN_KEYS } from "./add.js";
+import { installDeps } from "../utils/pm.js";
+import { log, CliError } from "../utils/logger.js";
+
+/**
+ * `init <project>` — délègue le scaffolding à `bun create elysia`, puis :
+ *  - pose la config elysia-cli + le dossier modules,
+ *  - déplace la route racine par défaut dans src/modules/index.ts,
+ *  - propose d'ajouter des plugins directement.
+ */
+export function registerInitCommand(program: Command) {
+  program
+    .command("init")
+    .description("Bootstrap d'un projet Elysia (via `bun create elysia`)")
+    .argument("[project]", "nom du dossier projet")
+    .option(
+      "--skip-scaffold",
+      "ne pas lancer `bun create elysia` (dossier déjà existant)",
+    )
+    .action(async (project?: string, opts?: { skipScaffold?: boolean }) => {
+      let name = project;
+      if (!name) {
+        const answer = await p.text({
+          message: "Nom du projet ?",
+          placeholder: "my-api",
+          validate: nameError,
+        });
+        if (p.isCancel(answer)) throw new CliError("Annulé.");
+        name = answer as string;
+      }
+      assertValidName(name);
+
+      const root = join(process.cwd(), name);
+
+      // 1. Scaffolding officiel Elysia (OK si dossier inexistant ou vide).
+      if (!opts?.skipScaffold) {
+        if (existsSync(root) && !isEmptyDir(root)) {
+          throw new CliError(
+            `Le dossier ${name} existe déjà et n'est pas vide ` +
+              `(utilise --skip-scaffold pour l'enrichir).`,
+          );
+        }
+        log.title(`Scaffolding : bun create elysia ${name}`);
+        const res = spawnSync("bun", ["create", "elysia", name], {
+          stdio: "inherit",
+          cwd: process.cwd(),
+          shell: true,
+        });
+        if (res.error) {
+          throw new CliError(
+            "Impossible de lancer `bun`. Bun est-il installé ? (bun --version)",
+          );
+        }
+        if (res.status !== 0) throw new CliError("`bun create elysia` a échoué.");
+      } else if (!existsSync(root)) {
+        throw new CliError(`Le dossier ${name} n'existe pas — retire --skip-scaffold.`);
+      }
+
+      // À partir d'ici on travaille DANS le projet.
+      process.chdir(root);
+
+      // 2. Config elysia-cli + dossier modules.
+      log.title("Configuration elysia-cli");
+      const config: ElysiaCliConfig = {
+        srcDir: "src",
+        modulesDir: "src/modules",
+        appEntry: "src/index.ts",
+        appVariable: "app",
+        modulesEntry: "src/modules/index.ts",
+        modulesVariable: "modules",
+      };
+      mkdirSync(config.modulesDir, { recursive: true });
+
+      const configPath = "elysia-cli.config.json";
+      if (existsSync(configPath)) {
+        log.skipped(configPath);
+      } else {
+        writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+        log.created(configPath);
+      }
+
+      // 3. Déplace la route racine par défaut dans src/modules/index.ts.
+      relocateRootRoute(config);
+
+      // 4. Plugins à ajouter directement.
+      const selected = await p.multiselect({
+        message: "Plugins à ajouter maintenant ? (espace pour sélectionner)",
+        options: PLUGIN_KEYS.map((k) => ({ value: k, label: k })),
+        required: false,
+      });
+      if (!p.isCancel(selected) && Array.isArray(selected) && selected.length) {
+        log.title("Ajout des plugins");
+        // Ordre canonique (prisma avant better-auth pour l'adapter).
+        const chosen = PLUGIN_KEYS.filter((k) => (selected as string[]).includes(k));
+        const pkgs = new Set<string>();
+        const devPkgs = new Set<string>();
+        const posts: Array<() => void> = [];
+        for (const key of chosen) {
+          const res = await applyPlugin(key, config);
+          res.pkgs.forEach((x) => pkgs.add(x));
+          res.devPkgs.forEach((x) => devPkgs.add(x));
+          if (res.postInstall) posts.push(res.postInstall);
+        }
+        installDeps([...pkgs]);
+        installDeps([...devPkgs], { dev: true });
+        for (const fn of posts) fn();
+      }
+
+      log.success(`Projet ${name} prêt.`);
+      log.info(`cd ${name} && bun dev`);
+    });
+}
+
+/** Décroche la route `.get("/")` de l'app entry et la place dans le module racine. */
+function relocateRootRoute(config: ElysiaCliConfig): void {
+  const project = loadTsProject();
+  const app = { entry: config.appEntry, variable: config.appVariable };
+  const handler = removeRootRoute(project, app);
+
+  if (!existsSync(config.modulesEntry)) {
+    mkdirSync(config.modulesDir, { recursive: true });
+    writeFileSync(
+      config.modulesEntry,
+      modulesIndexTemplate(handler ?? '() => "Hello Elysia"'),
+      "utf8",
+    );
+    log.created(config.modulesEntry);
+  } else {
+    log.skipped(config.modulesEntry);
+  }
+
+  registerUse(project, app, {
+    useExpr: config.modulesVariable,
+    ensureImport: {
+      names: [config.modulesVariable],
+      moduleSpecifier: moduleSpecifierFrom(config.appEntry, config.modulesDir),
+    },
+  });
+}
+
+/** Un dossier est considéré « vide » s'il ne contient que des fichiers bruit. */
+function isEmptyDir(dir: string): boolean {
+  const IGNORED = new Set([".git", ".DS_Store", "Thumbs.db", ".keep", ".gitkeep"]);
+  return readdirSync(dir).every((entry) => IGNORED.has(entry));
+}

package/src/commands/macro.ts

@@ -0,0 +1,68 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { Command } from "commander";
+import * as p from "@clack/prompts";
+import { buildNames, nameError, assertValidName } from "../utils/naming.js";
+import { loadConfig, loadTsProject } from "../utils/project.js";
+import { registerUse, moduleSpecifierFrom } from "../utils/inject.js";
+import { macroTemplate } from "../templates.js";
+import { log, CliError } from "../utils/logger.js";
+
+/**
+ * `macro <name>` — génère une macro Elysia dans `src/macros/<name>.macro.ts`
+ * et la branche dans l'app entry via `.use(<name>Macro)`.
+ */
+export function registerMacroCommand(program: Command) {
+  program
+    .command("macro")
+    .description("Génère une macro Elysia et la branche dans l'app")
+    .argument("[name]", "nom de la macro (ex: auth, roles)")
+    .option("--no-register", "ne pas injecter le .use() dans l'app entry")
+    .action(async (name?: string, opts?: { register: boolean }) => {
+      let n = name;
+      if (!n) {
+        const answer = await p.text({
+          message: "Nom de la macro ?",
+          placeholder: "auth",
+          validate: nameError,
+        });
+        if (p.isCancel(answer)) throw new CliError("Annulé.");
+        n = answer as string;
+      }
+      assertValidName(n);
+
+      const names = buildNames(n);
+      const config = loadConfig();
+
+      const rel = join(config.srcDir, "macros", `${names.kebab}.macro.ts`);
+      const target = join(process.cwd(), rel);
+      if (existsSync(target)) {
+        log.skipped(rel);
+      } else {
+        mkdirSync(join(process.cwd(), config.srcDir, "macros"), { recursive: true });
+        writeFileSync(target, macroTemplate(names), "utf8");
+        log.created(rel);
+      }
+
+      if (opts?.register ?? true) {
+        const project = loadTsProject();
+        const macroVar = `${names.camel}Macro`;
+        registerUse(
+          project,
+          { entry: config.appEntry, variable: config.appVariable },
+          {
+            useExpr: macroVar,
+            ensureImport: {
+              names: [macroVar],
+              moduleSpecifier: moduleSpecifierFrom(
+                config.appEntry,
+                join(config.srcDir, "macros", `${names.kebab}.macro`),
+              ),
+            },
+          },
+        );
+      }
+
+      log.success(`Macro ${names.camel} générée.`);
+    });
+}

package/src/index.ts

@@ -0,0 +1,37 @@
+#!/usr/bin/env bun
+import { Command } from "commander";
+import chalk from "chalk";
+import { log, CliError } from "./utils/logger.js";
+import { registerGenerateCommand } from "./commands/generate.js";
+import { registerAddCommand } from "./commands/add.js";
+import { registerInitCommand } from "./commands/init.js";
+import { registerMacroCommand } from "./commands/macro.js";
+import pkg from "../package.json" with { type: "json" };
+
+const program = new Command();
+
+program
+  .name("elysia-cli")
+  .description("Scaffolding pour projets ElysiaJS")
+  .version(pkg.version);
+
+registerGenerateCommand(program);
+registerAddCommand(program);
+registerInitCommand(program);
+registerMacroCommand(program);
+
+async function main() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    if (err instanceof CliError) {
+      log.error(err.message);
+    } else {
+      log.error("Erreur inattendue :");
+      console.error(chalk.red(String((err as Error)?.stack ?? err)));
+    }
+    process.exit(1);
+  }
+}
+
+main();