@aponiajs/cli 0.1.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aponiajs/cli",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Bun-native project generator and command-line interface for Aponia.",
   "homepage": "https://github.com/aponiajs/aponiajs#readme",
   "bugs": {
@@ -35,5 +35,15 @@
     "test": "bun test",
     "check": "bunx --bun vp check",
     "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "change-case": "^5.4.4",
+    "fast-glob": "^3.3.3",
+    "inflection": "^3.0.2",
+    "ts-morph": "^28.0.0",
+    "yargs-parser": "^22.0.0"
+  },
+  "devDependencies": {
+    "@types/yargs-parser": "^21.0.3"
   }
 }

package/src/arguments.ts

@@ -1,3 +1,6 @@
+import { pascalCase } from "change-case";
+import parseCliArguments from "yargs-parser";
+
 export interface NewCommandOptions {
   readonly command: "new";
   readonly name: string;
@@ -5,11 +8,104 @@ export interface NewCommandOptions {
   readonly skipInstall: boolean;
 }
 
+export const generateSchematics = [
+  "app",
+  "library",
+  "class",
+  "controller",
+  "decorator",
+  "filter",
+  "gateway",
+  "guard",
+  "interface",
+  "interceptor",
+  "middleware",
+  "module",
+  "pipe",
+  "provider",
+  "resolver",
+  "resource",
+  "service",
+] as const;
+
+export type GenerateSchematic = (typeof generateSchematics)[number];
+
+export type ResourceTransport =
+  | "rest"
+  | "graphql-code-first"
+  | "graphql-schema-first"
+  | "microservice"
+  | "ws";
+
+export interface GenerateCommandOptions {
+  readonly command: "generate";
+  readonly schematic: GenerateSchematic;
+  readonly name: string;
+  readonly dryRun: boolean;
+  readonly flat?: boolean;
+  readonly spec?: boolean;
+  readonly skipImport: boolean;
+  readonly path?: string;
+  readonly module?: string;
+  readonly project?: string;
+  readonly crud: boolean;
+  readonly type: ResourceTransport;
+}
+
 export type CliCommand =
   | NewCommandOptions
+  | GenerateCommandOptions
   | { readonly command: "help" }
   | { readonly command: "version" };
 
+const schematicAliases: Readonly<Record<string, GenerateSchematic>> = {
+  app: "app",
+  application: "app",
+  lib: "library",
+  library: "library",
+  cl: "class",
+  class: "class",
+  co: "controller",
+  controller: "controller",
+  route: "controller",
+  router: "controller",
+  routes: "controller",
+  d: "decorator",
+  decorator: "decorator",
+  f: "filter",
+  filter: "filter",
+  ga: "gateway",
+  gateway: "gateway",
+  gu: "guard",
+  guard: "guard",
+  itf: "interface",
+  interface: "interface",
+  itc: "interceptor",
+  interceptor: "interceptor",
+  mi: "middleware",
+  middleware: "middleware",
+  mo: "module",
+  module: "module",
+  pi: "pipe",
+  pipe: "pipe",
+  pr: "provider",
+  provider: "provider",
+  r: "resolver",
+  resolver: "resolver",
+  res: "resource",
+  resource: "resource",
+  s: "service",
+  service: "service",
+};
+
+const resourceTransports = new Set<ResourceTransport>([
+  "rest",
+  "graphql-code-first",
+  "graphql-schema-first",
+  "microservice",
+  "ws",
+]);
+
 export function parseArguments(arguments_: readonly string[]): CliCommand {
   const [command = "help", ...rest] = arguments_;
 
@@ -21,27 +117,145 @@ export function parseArguments(arguments_: readonly string[]): CliCommand {
     return { command: "version" };
   }
 
-  if (command !== "new" && command !== "n") {
-    throw new Error(`Unknown command "${command}".`);
+  if (command === "new" || command === "n") {
+    return parseNewCommand(rest);
+  }
+
+  if (command === "generate" || command === "g") {
+    return parseGenerateCommand(rest);
   }
 
-  const name = rest.find((argument) => !argument.startsWith("-"));
+  throw new Error(`Unknown command "${command}".`);
+}
+
+function parseNewCommand(arguments_: readonly string[]): NewCommandOptions {
+  const parsed = parseOptions(arguments_);
+  const [name, ...extraPositionals] = parsed._;
   if (!name) {
     throw new Error("Project name is required.");
   }
-
-  const supportedOptions = new Set(["--dry-run", "-d", "--skip-install", "-s"]);
-  const unknownOption = rest.find(
-    (argument) => argument.startsWith("-") && !supportedOptions.has(argument),
-  );
-  if (unknownOption) {
-    throw new Error(`Unknown option "${unknownOption}".`);
+  if (extraPositionals.length > 0) {
+    throw new Error(`Unexpected argument "${extraPositionals[0]}".`);
   }
 
+  assertKnownOptions(parsed, ["dry-run", "skip-install"]);
+
   return {
     command: "new",
     name,
-    dryRun: rest.includes("--dry-run") || rest.includes("-d"),
-    skipInstall: rest.includes("--skip-install") || rest.includes("-s"),
+    dryRun: readBooleanOption(parsed, "dry-run", false),
+    skipInstall: readBooleanOption(parsed, "skip-install", false),
+  };
+}
+
+function parseGenerateCommand(arguments_: readonly string[]): GenerateCommandOptions {
+  const parsed = parseOptions(arguments_);
+  const [schematicName, name, ...extraPositionals] = parsed._;
+  if (!schematicName) {
+    throw new Error("Schematic name is required.");
+  }
+
+  const schematic = schematicAliases[schematicName];
+  if (!schematic) {
+    throw new Error(
+      `Unknown schematic "${schematicName}". Available schematics: ${generateSchematics.join(", ")}.`,
+    );
+  }
+  if (!name) {
+    throw new Error(`${pascalCase(schematic)} name is required.`);
+  }
+  if (extraPositionals.length > 0) {
+    throw new Error(`Unexpected argument "${extraPositionals[0]}".`);
+  }
+
+  assertKnownOptions(parsed, [
+    "crud",
+    "dry-run",
+    "flat",
+    "module",
+    "path",
+    "project",
+    "skip-import",
+    "spec",
+    "type",
+  ]);
+
+  const type = readStringOption(parsed, "type") ?? "rest";
+  if (!resourceTransports.has(type as ResourceTransport)) {
+    throw new Error(`Unknown resource transport "${type}".`);
+  }
+
+  return {
+    command: "generate",
+    schematic,
+    name,
+    dryRun: readBooleanOption(parsed, "dry-run", false),
+    flat: readOptionalBooleanOption(parsed, "flat"),
+    spec: readOptionalBooleanOption(parsed, "spec"),
+    skipImport: readBooleanOption(parsed, "skip-import", false),
+    path: readStringOption(parsed, "path"),
+    module: readStringOption(parsed, "module"),
+    project: readStringOption(parsed, "project"),
+    crud: readBooleanOption(parsed, "crud", true),
+    type: type as ResourceTransport,
   };
 }
+
+interface ParsedOptions extends Readonly<Record<string, unknown>> {
+  readonly _: readonly string[];
+}
+
+function parseOptions(arguments_: readonly string[]): ParsedOptions {
+  return parseCliArguments([...arguments_], {
+    alias: {
+      "dry-run": ["d"],
+      project: ["p"],
+      "skip-install": ["s"],
+    },
+    boolean: ["crud", "dry-run", "flat", "skip-import", "skip-install", "spec"],
+    string: ["module", "path", "project", "type"],
+    configuration: {
+      "camel-case-expansion": false,
+      "dot-notation": false,
+      "duplicate-arguments-array": false,
+      "parse-numbers": false,
+      "parse-positional-numbers": false,
+      "short-option-groups": false,
+      "strip-aliased": true,
+    },
+  }) as ParsedOptions;
+}
+
+function assertKnownOptions(options: ParsedOptions, supportedOptions: readonly string[]): void {
+  const supported = new Set(supportedOptions);
+  const unknown = Object.keys(options).find((option) => option !== "_" && !supported.has(option));
+  if (unknown) {
+    throw new Error(`Unknown option "--${unknown}".`);
+  }
+}
+
+function readBooleanOption(options: ParsedOptions, name: string, fallback: boolean): boolean {
+  return readOptionalBooleanOption(options, name) ?? fallback;
+}
+
+function readOptionalBooleanOption(options: ParsedOptions, name: string): boolean | undefined {
+  const value = options[name];
+  if (value === undefined) {
+    return undefined;
+  }
+  if (typeof value !== "boolean") {
+    throw new Error(`Option "--${name}" does not accept a value.`);
+  }
+  return value;
+}
+
+function readStringOption(options: ParsedOptions, name: string): string | undefined {
+  const value = options[name];
+  if (value === undefined) {
+    return undefined;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`Option "--${name}" requires a value.`);
+  }
+  return value;
+}

package/src/component-names.ts

@@ -0,0 +1,42 @@
+import { camelCase, kebabCase, pascalCase } from "change-case";
+import { singularize } from "inflection";
+import { isAbsolute } from "node:path";
+
+export interface ComponentNames {
+  readonly fileName: string;
+  readonly className: string;
+  readonly propertyName: string;
+  readonly singularFileName: string;
+  readonly singularClassName: string;
+  readonly routePath: string;
+}
+
+export function createComponentNames(input: string): ComponentNames {
+  const segments = normalizeNameSegments(input);
+  const fileName = segments.at(-1)!;
+  const singularFileName = singularize(fileName);
+  return {
+    fileName,
+    className: pascalCase(fileName),
+    propertyName: camelCase(fileName),
+    singularFileName,
+    singularClassName: pascalCase(singularFileName),
+    routePath: fileName,
+  };
+}
+
+export function normalizeNameSegments(input: string): string[] {
+  if (isAbsolute(input) || input.includes("..")) {
+    throw new Error("Generated names must be relative and cannot contain parent traversal.");
+  }
+
+  const segments = input
+    .replaceAll("\\", "/")
+    .split("/")
+    .filter(Boolean)
+    .map((segment) => kebabCase(segment, { locale: false }));
+  if (segments.length === 0 || segments.some((segment) => !/^[a-z][a-z0-9-]*$/.test(segment))) {
+    throw new Error("Generated names must contain letters and use kebab-case paths.");
+  }
+  return segments;
+}

package/src/index.ts

@@ -1,13 +1,27 @@
 import cliManifest from "../package.json" with { type: "json" };
 import { parseArguments } from "./arguments.ts";
 import { generateProject } from "./project-generator.ts";
+import { generateSchematic } from "./schematic-generator.ts";
 
-export { parseArguments, type CliCommand } from "./arguments.ts";
+export {
+  generateSchematics,
+  parseArguments,
+  type CliCommand,
+  type GenerateCommandOptions,
+  type GenerateSchematic,
+  type ResourceTransport,
+} from "./arguments.ts";
 export {
   generateProject,
   type GenerateProjectOptions,
   type GenerateProjectResult,
 } from "./project-generator.ts";
+export {
+  generateSchematic,
+  type GenerateSchematicOptions,
+  type GenerateSchematicResult,
+  type SchematicChange,
+} from "./schematic-generator.ts";
 
 export async function runCli(arguments_: readonly string[]): Promise<number> {
   try {
@@ -23,6 +37,14 @@ export async function runCli(arguments_: readonly string[]): Promise<number> {
       return 0;
     }
 
+    if (command.command === "generate") {
+      const result = await generateSchematic(command);
+      for (const change of result.changes) {
+        console.log(`${change.kind} ${change.path}`);
+      }
+      return 0;
+    }
+
     const result = await generateProject(command);
     if (result.dryRun) {
       console.log(`CREATE ${result.projectDirectory}`);
@@ -47,10 +69,32 @@ const helpText = `Aponia CLI
 Usage:
   aponia new <name> [options]
   aponia n <name> [options]
+  aponia generate <schematic> <name> [options]
+  aponia g <schematic> <name> [options]
 
 Options:
   -d, --dry-run       Report files without writing them
   -s, --skip-install  Generate without running bun install
+      --flat          Generate without a schematic directory
+      --no-flat       Generate inside a schematic directory
+      --spec          Generate spec files
+      --no-spec       Skip spec files
+      --skip-import   Skip declaring module registration
+      --module <name> Select the declaring module
+      --path <path>   Override the configured source root
+  -p, --project       Select a configured project
+      --type <type>   Select a resource transport
+      --crud          Generate CRUD entry points (default)
+      --no-crud       Generate a resource without CRUD entry points
   -h, --help          Show command help
   -v, --version       Show CLI version
+
+Schematics:
+  app, library (lib), class (cl), controller (co), decorator (d),
+  filter (f), gateway (ga), guard (gu), interface (itf),
+  interceptor (itc), middleware (mi), module (mo), pipe (pi),
+  provider (pr), resolver (r), resource (res), service (s)
+
+Controller aliases:
+  router, routers, route
 `;

package/src/module-registration.ts

@@ -0,0 +1,115 @@
+import {
+  IndentationText,
+  Node,
+  Project,
+  QuoteKind,
+  SyntaxKind,
+  type ObjectLiteralExpression,
+  type SourceFile,
+} from "ts-morph";
+
+export type ModuleRegistrationKind = "controllers" | "imports" | "providers";
+
+export function registerInModule(
+  source: string,
+  registrationKind: ModuleRegistrationKind,
+  symbol: string,
+  importPath: string,
+): string {
+  const project = new Project({
+    useInMemoryFileSystem: true,
+    manipulationSettings: {
+      indentationText: IndentationText.TwoSpaces,
+      quoteKind: QuoteKind.Double,
+    },
+  });
+  const sourceFile = project.createSourceFile("module.ts", source);
+  const moduleMetadata = findModuleMetadata(sourceFile);
+  if (!moduleMetadata) {
+    throw new Error("The declaring module does not contain a @Module() metadata object.");
+  }
+
+  if (isAlreadyRegistered(sourceFile, registrationKind, symbol, importPath)) {
+    return source;
+  }
+
+  addImport(sourceFile, symbol, importPath);
+  addRegistration(moduleMetadata, registrationKind, symbol);
+  return sourceFile.getFullText();
+}
+
+function findModuleMetadata(sourceFile: SourceFile): ObjectLiteralExpression | undefined {
+  const moduleCall = sourceFile
+    .getDescendantsOfKind(SyntaxKind.CallExpression)
+    .find((callExpression) => callExpression.getExpression().getText() === "Module");
+  const metadata = moduleCall?.getArguments()[0];
+  return Node.isObjectLiteralExpression(metadata) ? metadata : undefined;
+}
+
+function isAlreadyRegistered(
+  sourceFile: SourceFile,
+  registrationKind: ModuleRegistrationKind,
+  symbol: string,
+  importPath: string,
+): boolean {
+  const hasImport = sourceFile
+    .getImportDeclarations()
+    .some(
+      (declaration) =>
+        declaration.getModuleSpecifierValue() === importPath &&
+        declaration.getNamedImports().some((namedImport) => namedImport.getName() === symbol),
+    );
+  if (!hasImport) return false;
+
+  const metadata = findModuleMetadata(sourceFile);
+  const registration = metadata?.getProperty(registrationKind);
+  if (!Node.isPropertyAssignment(registration)) return false;
+  const initializer = registration.getInitializer();
+  return (
+    Node.isArrayLiteralExpression(initializer) &&
+    initializer.getElements().some((element) => element.getText() === symbol)
+  );
+}
+
+function addImport(sourceFile: SourceFile, symbol: string, importPath: string): void {
+  const existingImport = sourceFile
+    .getImportDeclarations()
+    .find((declaration) => declaration.getModuleSpecifierValue() === importPath);
+  if (existingImport) {
+    if (!existingImport.getNamedImports().some((namedImport) => namedImport.getName() === symbol)) {
+      existingImport.addNamedImport(symbol);
+    }
+    return;
+  }
+
+  sourceFile.addImportDeclaration({
+    namedImports: [symbol],
+    moduleSpecifier: importPath,
+  });
+}
+
+function addRegistration(
+  metadata: ObjectLiteralExpression,
+  registrationKind: ModuleRegistrationKind,
+  symbol: string,
+): void {
+  const registration = metadata.getProperty(registrationKind);
+  if (!registration) {
+    metadata.addPropertyAssignment({
+      name: registrationKind,
+      initializer: `[${symbol}]`,
+    });
+    return;
+  }
+
+  if (!Node.isPropertyAssignment(registration)) {
+    throw new Error(`Module metadata "${registrationKind}" must be a property assignment.`);
+  }
+  const initializer = registration.getInitializer();
+  if (!Node.isArrayLiteralExpression(initializer)) {
+    throw new Error(`Module metadata "${registrationKind}" must be an array.`);
+  }
+  if (!initializer.getElements().some((element) => element.getText() === symbol)) {
+    initializer.addElement(symbol);
+  }
+}