@apc-projects/elysia-cli 0.1.0

package/src/utils/inject.ts

@@ -0,0 +1,242 @@
+import { existsSync } from "node:fs";
+import { resolve, relative, dirname } from "node:path";
+import {
+  SyntaxKind,
+  type Project,
+  type SourceFile,
+  type NewExpression,
+  type PropertyAccessExpression,
+} from "ts-morph";
+import { log } from "./logger.js";
+
+/** Cible d'injection : un fichier + le nom de la variable de l'instance Elysia. */
+export interface InjectTarget {
+  entry: string;
+  variable: string;
+}
+
+interface ImportSpec {
+  names: string[];
+  moduleSpecifier: string;
+}
+
+/**
+ * Greffe un maillon de chaîne (`segment`, commençant par `.`) juste après
+ * `new Elysia(...)`. AST-based (ts-morph), robuste au formatage et idempotent
+ * via `dedupe` (sous-chaîne dont la présence signale un no-op).
+ */
+export function appendChain(
+  project: Project,
+  target: InjectTarget,
+  segment: string,
+  opts: { dedupe?: string; ensureImports?: ImportSpec[] } = {},
+): boolean {
+  const source = openEntry(project, target.entry);
+  if (!source) return false;
+
+  const elysiaNew = findElysiaInstance(source, target.variable);
+  if (!elysiaNew) {
+    log.warn(
+      `Aucune instance \`new Elysia()\` (variable \`${target.variable}\`) dans ` +
+        `${target.entry}. Segment non injecté.`,
+    );
+    return false;
+  }
+
+  const scope =
+    elysiaNew.getFirstAncestorByKind(SyntaxKind.VariableStatement) ??
+    elysiaNew.getFirstAncestorByKind(SyntaxKind.ExpressionStatement);
+  const marker = opts.dedupe ?? segment;
+  if ((scope ?? source).getText().includes(marker)) {
+    log.skipped(`${target.entry} (déjà présent)`);
+    return false;
+  }
+
+  elysiaNew.replaceWithText(`${elysiaNew.getText()}\n  ${segment}`);
+  for (const spec of opts.ensureImports ?? []) ensureImport(source, spec);
+
+  source.saveSync();
+  log.updated(target.entry);
+  return true;
+}
+
+/** Raccourci : injecte `.use(<useExpr>)`. */
+export function registerUse(
+  project: Project,
+  target: InjectTarget,
+  opts: { useExpr: string; ensureImport?: ImportSpec },
+): boolean {
+  return appendChain(project, target, `.use(${opts.useExpr})`, {
+    dedupe: `.use(${opts.useExpr})`,
+    ensureImports: opts.ensureImport ? [opts.ensureImport] : undefined,
+  });
+}
+
+/**
+ * Ré-écrit un appel `openapi()` déjà présent dans l'app entry pour y injecter
+ * la doc better-auth, et garantit l'import de `OpenAPI`. No-op si aucun appel
+ * `openapi(...)` n'est trouvé, ou s'il est déjà intégré.
+ */
+export function patchOpenapiWithAuth(
+  project: Project,
+  appEntry: string,
+  authImportPath: string,
+): boolean {
+  const source = openEntry(project, appEntry);
+  if (!source) return false;
+
+  // Déjà intégré.
+  if (source.getText().includes("OpenAPI.getPaths")) return false;
+
+  const call = source
+    .getDescendantsOfKind(SyntaxKind.CallExpression)
+    .find((c) => c.getExpression().getText() === "openapi");
+  if (!call) return false;
+
+  call.replaceWithText(
+    "openapi({ enabled : process.env.NODE_ENV !== \"production\", documentation: { components: await OpenAPI.components, " +
+      "paths: await OpenAPI.getPaths() } })",
+  );
+  ensureImport(source, {
+    names: ["OpenAPI"],
+    moduleSpecifier: moduleSpecifierFrom(appEntry, authImportPath),
+  });
+
+  source.saveSync();
+  log.updated(`${appEntry} (openapi ↔ better-auth intégré)`);
+  return true;
+}
+
+/**
+ * Retire la route racine par défaut (`.get("/", ...)`) de la cible et renvoie
+ * le texte du handler pour le replacer ailleurs. `null` si absente.
+ */
+export function removeRootRoute(
+  project: Project,
+  target: InjectTarget,
+): string | null {
+  const source = openEntry(project, target.entry);
+  if (!source) return null;
+
+  const getCall = source
+    .getDescendantsOfKind(SyntaxKind.CallExpression)
+    .find((call) => {
+      const expr = call.getExpression();
+      if (expr.getKind() !== SyntaxKind.PropertyAccessExpression) return false;
+      if ((expr as PropertyAccessExpression).getName() !== "get") return false;
+      const first = call.getArguments()[0];
+      if (!first || first.getKind() !== SyntaxKind.StringLiteral) return false;
+      return first.getText().replace(/['"]/g, "") === "/";
+    });
+
+  if (!getCall) return null;
+
+  const handler = getCall.getArguments()[1]?.getText() ?? '() => "Hello Elysia"';
+  const objText = (getCall.getExpression() as PropertyAccessExpression)
+    .getExpression()
+    .getText();
+  getCall.replaceWithText(objText);
+
+  source.saveSync();
+  log.updated(`${target.entry} (route racine déplacée)`);
+  return handler;
+}
+
+const CONSOLE_MAP: Record<string, string> = {
+  log: "Logger.app.info",
+  info: "Logger.app.info",
+  debug: "Logger.app.debug",
+  warn: "Logger.app.warn",
+  error: "Logger.app.error",
+};
+
+/** Remplace les `console.*` de la cible par le Logger, et garantit son import. */
+export function replaceConsoleWithLogger(
+  project: Project,
+  target: InjectTarget,
+  loggerPath: string,
+): number {
+  const source = openEntry(project, target.entry);
+  if (!source) return 0;
+
+  let changed = 0;
+  for (;;) {
+    const pae = source
+      .getDescendantsOfKind(SyntaxKind.PropertyAccessExpression)
+      .find(
+        (pa) =>
+          pa.getExpression().getText() === "console" && pa.getName() in CONSOLE_MAP,
+      );
+    if (!pae) break;
+    pae.replaceWithText(CONSOLE_MAP[pae.getName()]);
+    changed++;
+    if (changed > 200) break; // garde-fou
+  }
+
+  if (changed > 0) {
+    ensureImport(source, {
+      names: ["Logger"],
+      moduleSpecifier: moduleSpecifierFrom(target.entry, loggerPath),
+    });
+    source.saveSync();
+    log.updated(`${target.entry} (console.* → Logger ×${changed})`);
+  }
+  return changed;
+}
+
+/** Specifier d'import relatif depuis `fromEntry` vers un fichier cible. */
+export function moduleSpecifierFrom(fromEntry: string, targetPath: string): string {
+  const fromAbs = resolve(process.cwd(), fromEntry);
+  const rel = relative(dirname(fromAbs), resolve(process.cwd(), targetPath))
+    .replace(/\\/g, "/")
+    .replace(/\.ts$/, "");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+
+// ---------------------------------------------------------------------------
+
+function openEntry(project: Project, entry: string): SourceFile | null {
+  const abs = resolve(process.cwd(), entry);
+  if (!existsSync(abs)) {
+    log.warn(`Fichier cible introuvable (${entry}) — injection ignorée.`);
+    return null;
+  }
+  return (
+    project.addSourceFileAtPathIfExists(abs) ?? project.addSourceFileAtPath(abs)
+  );
+}
+
+function ensureImport(source: SourceFile, spec: ImportSpec): void {
+  const existing = source
+    .getImportDeclarations()
+    .find((d) => d.getModuleSpecifierValue() === spec.moduleSpecifier);
+  if (!existing) {
+    source.addImportDeclaration({
+      moduleSpecifier: spec.moduleSpecifier,
+      namedImports: spec.names,
+    });
+    return;
+  }
+  const present = new Set(existing.getNamedImports().map((n) => n.getName()));
+  for (const name of spec.names) {
+    if (!present.has(name)) existing.addNamedImport(name);
+  }
+}
+
+function findElysiaInstance(
+  source: SourceFile,
+  variable: string,
+): NewExpression | undefined {
+  const decl = source.getVariableDeclaration(variable);
+  if (decl) {
+    const fromDecl = decl
+      .getDescendantsOfKind(SyntaxKind.NewExpression)
+      .find(isElysia);
+    if (fromDecl) return fromDecl;
+  }
+  return source.getDescendantsOfKind(SyntaxKind.NewExpression).find(isElysia);
+}
+
+function isElysia(node: NewExpression): boolean {
+  return node.getExpression().getText() === "Elysia";
+}

package/src/utils/logger.ts

@@ -0,0 +1,21 @@
+import chalk from "chalk";
+
+/** Petits wrappers de sortie colorée, centralisés pour rester cohérents. */
+export const log = {
+  info: (msg: string) => console.log(chalk.cyan("ℹ"), msg),
+  success: (msg: string) => console.log(chalk.green("✔"), msg),
+  warn: (msg: string) => console.log(chalk.yellow("⚠"), msg),
+  error: (msg: string) => console.error(chalk.red("✖"), msg),
+  /** Affiche un fichier créé. */
+  created: (path: string) =>
+    console.log(`  ${chalk.green("+")} ${chalk.dim(path)}`),
+  /** Affiche un fichier modifié (injection). */
+  updated: (path: string) =>
+    console.log(`  ${chalk.yellow("~")} ${chalk.dim(path)}`),
+  /** Affiche un fichier ignoré (déjà présent). */
+  skipped: (path: string) =>
+    console.log(`  ${chalk.gray("=")} ${chalk.dim(path + " (existe déjà)")}`),
+  title: (msg: string) => console.log("\n" + chalk.bold(msg)),
+};
+
+export class CliError extends Error {}

package/src/utils/naming.ts

@@ -0,0 +1,88 @@
+/**
+ * Helpers de casse pour dériver les différentes formes d'un nom de module.
+ * Ex: "user-profile" ->
+ *   kebab:  user-profile
+ *   pascal: UserProfile
+ *   camel:  userProfile
+ *   plural: userProfiles
+ */
+
+import { CliError } from "./logger.js";
+
+/**
+ * Noms autorisés : commence par une lettre, puis lettres/chiffres/. _ -.
+ * Bloque les caractères qui permettraient une injection shell (le nom passe
+ * dans `bun create elysia <name>`) ou un path traversal (dossiers de modules).
+ */
+const NAME_RE = /^[a-zA-Z][a-zA-Z0-9._-]*$/;
+
+export function nameError(input: string): string | undefined {
+  if (!input.trim()) return "Nom requis";
+  if (input.length > 100) return "Nom trop long (max 100).";
+  if (!NAME_RE.test(input)) {
+    return "Autorisé : lettres, chiffres, . _ - (doit commencer par une lettre).";
+  }
+  return undefined;
+}
+
+/** Lève si le nom est invalide (à utiliser sur les noms passés en argument). */
+export function assertValidName(input: string): void {
+  const err = nameError(input);
+  if (err) throw new CliError(`Nom invalide "${input}" : ${err}`);
+}
+
+function splitWords(input: string): string[] {
+  return input
+    // sépare camelCase / PascalCase
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    // remplace séparateurs par des espaces
+    .replace(/[-_/\s]+/g, " ")
+    .trim()
+    .toLowerCase()
+    .split(" ")
+    .filter(Boolean);
+}
+
+export function toKebab(input: string): string {
+  return splitWords(input).join("-");
+}
+
+export function toPascal(input: string): string {
+  return splitWords(input)
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+    .join("");
+}
+
+export function toCamel(input: string): string {
+  const pascal = toPascal(input);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+
+/** Pluriel naïf en anglais — suffisant pour les chemins de route. */
+export function toPlural(word: string): string {
+  if (/[^aeiou]y$/i.test(word)) return word.replace(/y$/i, "ies");
+  if (/(s|sh|ch|x|z)$/i.test(word)) return word + "es";
+  return word + "s";
+}
+
+export interface NameSet {
+  raw: string;
+  kebab: string;
+  pascal: string;
+  camel: string;
+  camelPlural: string;
+  kebabPlural: string;
+}
+
+export function buildNames(input: string): NameSet {
+  const kebab = toKebab(input);
+  const camel = toCamel(input);
+  return {
+    raw: input,
+    kebab,
+    pascal: toPascal(input),
+    camel,
+    camelPlural: toPlural(camel),
+    kebabPlural: toPlural(kebab),
+  };
+}

package/src/utils/package-json.ts

@@ -0,0 +1,32 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { log } from "./logger.js";
+
+/**
+ * Ajoute des scripts au package.json du projet courant sans écraser ceux qui
+ * existent déjà. Conserve l'indentation à 2 espaces.
+ */
+export function ensureScripts(scripts: Record<string, string>): void {
+  const path = join(process.cwd(), "package.json");
+  if (!existsSync(path)) {
+    log.warn("package.json introuvable — scripts non ajoutés.");
+    return;
+  }
+
+  const pkg = JSON.parse(readFileSync(path, "utf8")) as {
+    scripts?: Record<string, string>;
+  };
+  pkg.scripts ??= {};
+
+  const added: string[] = [];
+  for (const [name, cmd] of Object.entries(scripts)) {
+    if (pkg.scripts[name] === undefined) {
+      pkg.scripts[name] = cmd;
+      added.push(name);
+    }
+  }
+  if (!added.length) return;
+
+  writeFileSync(path, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+  log.updated(`package.json (scripts : ${added.join(", ")})`);
+}

package/src/utils/pm.ts

@@ -0,0 +1,39 @@
+import { spawnSync } from "node:child_process";
+import { log, CliError } from "./logger.js";
+
+/**
+ * Installe des dépendances dans le projet courant via `bun add`.
+ * Dédoublonne, ignore la liste vide, et remonte une erreur si l'install échoue.
+ */
+export function installDeps(pkgs: string[], opts: { dev?: boolean } = {}): void {
+  const unique = [...new Set(pkgs)].filter(Boolean);
+  if (!unique.length) return;
+
+  const devFlag = opts.dev ? ["-d"] : [];
+  log.info(`Installation : bun add ${devFlag.join(" ")} ${unique.join(" ")}`.trim());
+  const res = spawnSync("bun", ["add", ...devFlag, ...unique], {
+    stdio: "inherit",
+    shell: true,
+  });
+  if (res.error) {
+    throw new CliError("Impossible de lancer `bun add` (Bun est-il installé ?).");
+  }
+  if (res.status !== 0) {
+    throw new CliError("`bun add` a échoué.");
+  }
+}
+
+/**
+ * Exécute une commande best-effort : logue, ne jette pas si elle échoue
+ * (utile pour les migrations qui nécessitent une base de données joignable).
+ * Retourne `true` si la commande a réussi.
+ */
+export function run(label: string, cmd: string, args: string[]): boolean {
+  log.info(`${label} : ${cmd} ${args.join(" ")}`);
+  const res = spawnSync(cmd, args, { stdio: "inherit", shell: true });
+  if (res.error || res.status !== 0) {
+    log.warn(`Échec de "${label}" — à relancer manuellement.`);
+    return false;
+  }
+  return true;
+}

package/src/utils/project.ts

@@ -0,0 +1,62 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { Project } from "ts-morph";
+import { CliError } from "./logger.js";
+
+export interface ElysiaCliConfig {
+  /** Racine du code source. */
+  srcDir: string;
+  /** Dossier où sont générés les modules. */
+  modulesDir: string;
+  /** Fichier d'entrée qui instancie l'app Elysia. */
+  appEntry: string;
+  /** Nom de la variable Elysia dans l'app entry (pour l'injection du .use()). */
+  appVariable: string;
+  /** Fichier agrégateur des modules (où `generate module` branche les controllers). */
+  modulesEntry: string;
+  /** Nom de la variable Elysia dans l'agrégateur des modules. */
+  modulesVariable: string;
+}
+
+const DEFAULT_CONFIG: ElysiaCliConfig = {
+  srcDir: "src",
+  modulesDir: "src/modules",
+  appEntry: "src/index.ts",
+  appVariable: "app",
+  modulesEntry: "src/modules/index.ts",
+  modulesVariable: "modules",
+};
+
+const CONFIG_FILE = "elysia-cli.config.json";
+
+/** Résout la config du projet cible (fichier optionnel + defaults). */
+export function loadConfig(cwd = process.cwd()): ElysiaCliConfig {
+  const configPath = join(cwd, CONFIG_FILE);
+  if (!existsSync(configPath)) return DEFAULT_CONFIG;
+  try {
+    const raw = JSON.parse(readFileSync(configPath, "utf8"));
+    return { ...DEFAULT_CONFIG, ...raw };
+  } catch (err) {
+    throw new CliError(
+      `Impossible de lire ${CONFIG_FILE}: ${(err as Error).message}`,
+    );
+  }
+}
+
+/**
+ * Charge un Project ts-morph pointant sur le tsconfig du projet cible.
+ * Utilisé pour les opérations d'injection (add / register de plugin).
+ */
+export function loadTsProject(cwd = process.cwd()): Project {
+  const tsconfigPath = join(cwd, "tsconfig.json");
+  if (existsSync(tsconfigPath)) {
+    return new Project({ tsConfigFilePath: tsconfigPath });
+  }
+  // Fallback sans tsconfig : projet en mémoire, on ajoute les fichiers à la demande.
+  return new Project({ skipAddingFilesFromTsConfig: true });
+}
+
+/** Chemin absolu vers le dossier d'un module. */
+export function moduleDir(config: ElysiaCliConfig, kebabName: string): string {
+  return resolve(process.cwd(), config.modulesDir, kebabName);
+}