@aponiajs/cli 0.1.0 → 0.2.1

package/dist/index.mjs

@@ -1,32 +1,189 @@
+import { camelCase, kebabCase, pascalCase } from "change-case";
+import parseCliArguments from "yargs-parser";
 import { mkdir, readdir } from "node:fs/promises";
-import { basename, dirname, join, relative } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
+import findFiles from "fast-glob";
+import { singularize } from "inflection";
+import { IndentationText, Node, Project, QuoteKind, SyntaxKind } from "ts-morph";
 //#region package.json
-var version = "0.1.0";
+var version = "0.2.1";
 //#endregion
 //#region src/arguments.ts
+const generateSchematics = [
+	"app",
+	"library",
+	"class",
+	"controller",
+	"decorator",
+	"filter",
+	"gateway",
+	"guard",
+	"interface",
+	"interceptor",
+	"middleware",
+	"module",
+	"pipe",
+	"provider",
+	"resolver",
+	"resource",
+	"service"
+];
+const schematicAliases = {
+	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 = /* @__PURE__ */ new Set([
+	"rest",
+	"graphql-code-first",
+	"graphql-schema-first",
+	"microservice",
+	"ws"
+]);
 function parseArguments(arguments_) {
 	const [command = "help", ...rest] = arguments_;
 	if (command === "help" || command === "--help" || command === "-h") return { command: "help" };
 	if (command === "version" || command === "--version" || command === "-v") return { command: "version" };
-	if (command !== "new" && command !== "n") throw new Error(`Unknown command "${command}".`);
-	const name = rest.find((argument) => !argument.startsWith("-"));
+	if (command === "new" || command === "n") return parseNewCommand(rest);
+	if (command === "generate" || command === "g") return parseGenerateCommand(rest);
+	throw new Error(`Unknown command "${command}".`);
+}
+function parseNewCommand(arguments_) {
+	const parsed = parseOptions(arguments_);
+	const [name, ...extraPositionals] = parsed._;
 	if (!name) throw new Error("Project name is required.");
-	const supportedOptions = /* @__PURE__ */ 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_) {
+	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)) 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
+	};
+}
+function parseOptions(arguments_) {
+	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
+		}
+	});
+}
+function assertKnownOptions(options, supportedOptions) {
+	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, name, fallback) {
+	return readOptionalBooleanOption(options, name) ?? fallback;
+}
+function readOptionalBooleanOption(options, name) {
+	const value = options[name];
+	if (value === void 0) return;
+	if (typeof value !== "boolean") throw new Error(`Option "--${name}" does not accept a value.`);
+	return value;
+}
+function readStringOption(options, name) {
+	const value = options[name];
+	if (value === void 0) return;
+	if (typeof value !== "string") throw new Error(`Option "--${name}" requires a value.`);
+	return value;
+}
 //#endregion
 //#region src/project-generator.ts
 const projectNamePattern = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
@@ -82,6 +239,430 @@ async function listFiles(directory) {
 	}))).flat();
 }
 //#endregion
+//#region src/component-names.ts
+function createComponentNames(input) {
+	const fileName = normalizeNameSegments(input).at(-1);
+	const singularFileName = singularize(fileName);
+	return {
+		fileName,
+		className: pascalCase(fileName),
+		propertyName: camelCase(fileName),
+		singularFileName,
+		singularClassName: pascalCase(singularFileName),
+		routePath: fileName
+	};
+}
+function normalizeNameSegments(input) {
+	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;
+}
+//#endregion
+//#region src/module-registration.ts
+function registerInModule(source, registrationKind, symbol, importPath) {
+	const sourceFile = new Project({
+		useInMemoryFileSystem: true,
+		manipulationSettings: {
+			indentationText: IndentationText.TwoSpaces,
+			quoteKind: QuoteKind.Double
+		}
+	}).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) {
+	const metadata = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((callExpression) => callExpression.getExpression().getText() === "Module")?.getArguments()[0];
+	return Node.isObjectLiteralExpression(metadata) ? metadata : void 0;
+}
+function isAlreadyRegistered(sourceFile, registrationKind, symbol, importPath) {
+	if (!sourceFile.getImportDeclarations().some((declaration) => declaration.getModuleSpecifierValue() === importPath && declaration.getNamedImports().some((namedImport) => namedImport.getName() === symbol))) return false;
+	const registration = findModuleMetadata(sourceFile)?.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, symbol, importPath) {
+	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, registrationKind, symbol) {
+	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);
+}
+//#endregion
+//#region src/schematic-generator.ts
+const definitions = {
+	class: {
+		defaultFlat: true,
+		spec: true,
+		suffix: ""
+	},
+	controller: {
+		defaultFlat: false,
+		spec: true,
+		suffix: "controller",
+		registration: "controllers"
+	},
+	decorator: {
+		defaultFlat: true,
+		spec: false,
+		suffix: "decorator"
+	},
+	filter: {
+		defaultFlat: true,
+		spec: true,
+		suffix: "filter"
+	},
+	gateway: {
+		defaultFlat: true,
+		spec: true,
+		suffix: "gateway",
+		registration: "providers"
+	},
+	guard: {
+		defaultFlat: true,
+		spec: true,
+		suffix: "guard"
+	},
+	interface: {
+		defaultFlat: true,
+		spec: false,
+		suffix: "interface"
+	},
+	interceptor: {
+		defaultFlat: true,
+		spec: true,
+		suffix: "interceptor"
+	},
+	middleware: {
+		defaultFlat: true,
+		spec: true,
+		suffix: "middleware"
+	},
+	module: {
+		defaultFlat: false,
+		spec: false,
+		suffix: "module",
+		registration: "imports"
+	},
+	pipe: {
+		defaultFlat: true,
+		spec: true,
+		suffix: "pipe"
+	},
+	provider: {
+		defaultFlat: true,
+		spec: true,
+		suffix: "",
+		registration: "providers"
+	},
+	resolver: {
+		defaultFlat: false,
+		spec: true,
+		suffix: "resolver",
+		registration: "providers"
+	},
+	service: {
+		defaultFlat: false,
+		spec: true,
+		suffix: "service",
+		registration: "providers"
+	}
+};
+async function generateSchematic(options) {
+	const projectRoot = resolve(options.cwd ?? process.cwd());
+	const names = createComponentNames(options.name);
+	if (options.schematic === "app") return generateApplication(projectRoot, names.fileName, options);
+	if (options.schematic === "library") return generateLibrary(projectRoot, names, options);
+	const configuration = await readConfiguration(projectRoot);
+	const project = resolveProject(configuration, options.project);
+	const sourceRoot = resolveInside(projectRoot, project.sourceRoot ?? configuration.sourceRoot ?? "src");
+	const basePath = options.path ? resolveInside(projectRoot, options.path) : sourceRoot;
+	const spec = options.spec ?? readSpecDefault(project.generateOptions?.spec, options.schematic) ?? readSpecDefault(configuration.generateOptions?.spec, options.schematic) ?? true;
+	const effectiveOptions = {
+		...options,
+		flat: options.flat ?? project.generateOptions?.flat ?? configuration.generateOptions?.flat
+	};
+	const files = options.schematic === "resource" ? createResourceFiles(basePath, names, effectiveOptions, spec) : createComponentFiles(basePath, names, effectiveOptions, spec);
+	const registration = registrationFor(options.schematic);
+	if (registration && !options.skipImport) {
+		const primary = primaryFile(files, options.schematic);
+		const moduleFile = await findModuleFile({
+			projectRoot,
+			sourceRoot,
+			fromDirectory: dirname(primary.path),
+			requestedModule: options.module,
+			excludedFile: options.schematic === "module" ? primary.path : void 0
+		});
+		if (moduleFile) {
+			const original = await Bun.file(moduleFile).text();
+			const updated = registerInModule(original, registration, symbolFor(options.schematic, names), toImportPath(moduleFile, primary.path));
+			if (updated !== original) files.push({
+				path: moduleFile,
+				content: updated,
+				kind: "UPDATE"
+			});
+		}
+	}
+	return writePendingFiles(projectRoot, files, options.dryRun);
+}
+function createComponentFiles(basePath, names, options, specEnabled) {
+	const schematic = options.schematic;
+	const definition = definitions[schematic];
+	const flat = options.flat ?? definition.defaultFlat;
+	const directory = join(basePath, ...normalizeNameSegments(options.name).slice(0, -1), ...flat ? [] : [names.fileName]);
+	const stem = definition.suffix ? `${names.fileName}.${definition.suffix}` : names.fileName;
+	const files = [{
+		path: join(directory, `${stem}.ts`),
+		content: renderComponent(schematic, names),
+		kind: "CREATE"
+	}];
+	if (definition.spec && specEnabled) files.push({
+		path: join(directory, `${stem}.spec.ts`),
+		content: renderComponentSpec(schematic, names, stem),
+		kind: "CREATE"
+	});
+	return files;
+}
+function createResourceFiles(basePath, names, options, specEnabled) {
+	const flat = options.flat ?? false;
+	const directory = join(basePath, ...normalizeNameSegments(options.name).slice(0, -1), ...flat ? [] : [names.fileName]);
+	const transportStem = resourceTransportStem(options.type);
+	const dtoSuffix = options.type.startsWith("graphql") ? "input" : "dto";
+	const files = [createFile(directory, `${names.fileName}.module.ts`, renderResourceModule(names, transportStem)), createFile(directory, `${names.fileName}.service.ts`, renderResourceService(names, options.crud, dtoSuffix))];
+	if (options.crud) files.push(createFile(join(directory, "dto"), `create-${names.singularFileName}.${dtoSuffix}.ts`, renderCreateDto(names, dtoSuffix)), createFile(join(directory, "dto"), `update-${names.singularFileName}.${dtoSuffix}.ts`, renderUpdateDto(names, dtoSuffix)), createFile(join(directory, "entities"), `${names.singularFileName}.entity.ts`, renderEntity(names)));
+	if (options.type === "rest") files.push(createFile(directory, `${names.fileName}.controller.ts`, renderResourceController(names, options.crud)));
+	else files.push(createFile(directory, `${names.fileName}.${transportStem}.ts`, renderResourceTransport(names, options.type, options.crud)));
+	if (specEnabled) files.push(createFile(directory, `${names.fileName}.service.spec.ts`, options.crud ? renderResourceServiceSpec(names) : renderSimpleSpec(`./${names.fileName}.service.ts`, `${names.className}Service`)), createFile(directory, `${names.fileName}.${transportStem}.spec.ts`, renderResourceTransportSpec(names, transportStem)));
+	return files;
+}
+async function generateApplication(projectRoot, name, options) {
+	const appsDirectory = join(projectRoot, "apps");
+	if (!options.dryRun) await mkdir(appsDirectory, { recursive: true });
+	const result = await generateProject({
+		name,
+		cwd: appsDirectory,
+		dryRun: options.dryRun,
+		skipInstall: true
+	});
+	return {
+		dryRun: options.dryRun,
+		changes: result.files.map((file) => ({
+			kind: "CREATE",
+			path: join("apps", name, file)
+		}))
+	};
+}
+async function generateLibrary(projectRoot, names, options) {
+	const directory = join(projectRoot, "packages", names.fileName);
+	return writePendingFiles(projectRoot, [
+		createFile(directory, "package.json", `${JSON.stringify({
+			name: names.fileName,
+			version: "0.0.0",
+			private: true,
+			type: "module",
+			scripts: {
+				build: "bun build ./src/index.ts --outdir ./dist --target bun",
+				test: "bun test"
+			},
+			dependencies: { "@aponiajs/common": "latest" }
+		}, void 0, 2)}\n`),
+		createFile(join(directory, "src"), `${names.fileName}.module.ts`, `import { Module } from "@aponiajs/common";\n\n@Module({})\nexport class ${names.className}Module {}\n`),
+		createFile(join(directory, "src"), `${names.fileName}.service.ts`, `import { Injectable } from "@aponiajs/common";\n\n@Injectable()\nexport class ${names.className}Service {}\n`),
+		createFile(join(directory, "src"), `${names.fileName}.service.spec.ts`, renderSimpleSpec(`./${names.fileName}.service.ts`, `${names.className}Service`)),
+		createFile(join(directory, "src"), "index.ts", `export { ${names.className}Module } from "./${names.fileName}.module.ts";\nexport { ${names.className}Service } from "./${names.fileName}.service.ts";\n`)
+	], options.dryRun);
+}
+async function writePendingFiles(projectRoot, files, dryRun) {
+	const creates = files.filter((file) => file.kind === "CREATE");
+	for (const file of creates) if (await Bun.file(file.path).exists()) throw new Error(`File "${relative(projectRoot, file.path)}" already exists.`);
+	if (!dryRun) for (const file of files) {
+		await mkdir(dirname(file.path), { recursive: true });
+		await Bun.write(file.path, file.content);
+	}
+	return {
+		dryRun,
+		changes: files.map((file) => ({
+			kind: file.kind,
+			path: relative(projectRoot, file.path)
+		}))
+	};
+}
+function renderComponent(schematic, names) {
+	const className = `${names.className}${classSuffix(schematic)}`;
+	switch (schematic) {
+		case "controller": return `import { Controller } from "@aponiajs/common";\n\n@Controller("${names.routePath}")\nexport class ${className} {}\n`;
+		case "module": return `import { Module } from "@aponiajs/common";\n\n@Module({})\nexport class ${className} {}\n`;
+		case "service":
+		case "provider": return `import { Injectable } from "@aponiajs/common";\n\n@Injectable()\nexport class ${className} {}\n`;
+		case "decorator": return `export function ${className}(): MethodDecorator {\n  return () => undefined;\n}\n`;
+		case "interface": return `export interface ${className} {}\n`;
+		case "guard": return `export class ${className} {\n  canActivate(): boolean {\n    return true;\n  }\n}\n`;
+		case "interceptor": return `export class ${className} {\n  intercept<T>(next: () => T): T {\n    return next();\n  }\n}\n`;
+		case "middleware": return `export class ${className} {\n  async use(request: Request, next: () => Response | Promise<Response>): Promise<Response> {\n    void request;\n    return next();\n  }\n}\n`;
+		case "pipe": return `export class ${className} {\n  transform<T>(value: T): T {\n    return value;\n  }\n}\n`;
+		case "filter": return `export class ${className} {\n  catch(error: unknown): unknown {\n    return error;\n  }\n}\n`;
+		default: return `export class ${className} {}\n`;
+	}
+}
+function renderComponentSpec(schematic, names, stem) {
+	return renderSimpleSpec(`./${stem}.ts`, `${names.className}${classSuffix(schematic)}`);
+}
+function renderSimpleSpec(importPath, className) {
+	return `import { expect, test } from "bun:test";\nimport { ${className} } from "${importPath}";\n\ntest("${className} is defined", () => {\n  expect(new ${className}()).toBeDefined();\n});\n`;
+}
+function renderResourceModule(names, transportStem) {
+	const transportClass = `${names.className}${pascalCase(transportStem)}`;
+	const metadata = transportStem === "controller" ? `controllers: [${transportClass}],\n  providers: [${names.className}Service],` : `providers: [${transportClass}, ${names.className}Service],`;
+	return `import { Module } from "@aponiajs/common";\nimport { ${transportClass} } from "./${names.fileName}.${transportStem}.ts";\nimport { ${names.className}Service } from "./${names.fileName}.service.ts";\n\n@Module({\n  ${metadata}\n})\nexport class ${names.className}Module {}\n`;
+}
+function renderResourceController(names, crud) {
+	if (!crud) return `import { Controller } from "@aponiajs/common";\nimport { ${names.className}Service } from "./${names.fileName}.service.ts";\n\n@Controller("${names.routePath}")\nexport class ${names.className}Controller {\n  constructor(private readonly ${names.propertyName}Service: ${names.className}Service) {}\n}\n`;
+	return `import { Controller, Delete, Get, Patch, Post } from "@aponiajs/common";\nimport type { Create${names.singularClassName}Dto } from "./dto/create-${names.singularFileName}.dto.ts";\nimport type { Update${names.singularClassName}Dto } from "./dto/update-${names.singularFileName}.dto.ts";\nimport { ${names.className}Service } from "./${names.fileName}.service.ts";\n\n@Controller("${names.routePath}")\nexport class ${names.className}Controller {\n  constructor(private readonly ${names.propertyName}Service: ${names.className}Service) {}\n\n  @Post()\n  create(input: Create${names.singularClassName}Dto) {\n    return this.${names.propertyName}Service.create(input);\n  }\n\n  @Get()\n  findAll() {\n    return this.${names.propertyName}Service.findAll();\n  }\n\n  @Get(":id")\n  findOne(id: string) {\n    return this.${names.propertyName}Service.findOne(id);\n  }\n\n  @Patch(":id")\n  update(id: string, input: Update${names.singularClassName}Dto) {\n    return this.${names.propertyName}Service.update(id, input);\n  }\n\n  @Delete(":id")\n  remove(id: string) {\n    return this.${names.propertyName}Service.remove(id);\n  }\n}\n`;
+}
+function renderResourceService(names, crud, dtoSuffix) {
+	if (!crud) return `import { Injectable } from "@aponiajs/common";\n\n@Injectable()\nexport class ${names.className}Service {}\n`;
+	const typeSuffix = pascalCase(dtoSuffix);
+	return `import { Injectable } from "@aponiajs/common";\nimport type { Create${names.singularClassName}${typeSuffix} } from "./dto/create-${names.singularFileName}.${dtoSuffix}.ts";\nimport type { Update${names.singularClassName}${typeSuffix} } from "./dto/update-${names.singularFileName}.${dtoSuffix}.ts";\nimport type { ${names.singularClassName} } from "./entities/${names.singularFileName}.entity.ts";\n\n@Injectable()\nexport class ${names.className}Service {\n  private readonly items: ${names.singularClassName}[] = [];\n\n  create(input: Create${names.singularClassName}${typeSuffix}): ${names.singularClassName} {\n    const item = { id: crypto.randomUUID(), ...input };\n    this.items.push(item);\n    return item;\n  }\n\n  findAll(): readonly ${names.singularClassName}[] {\n    return this.items;\n  }\n\n  findOne(id: string): ${names.singularClassName} | undefined {\n    return this.items.find((item) => item.id === id);\n  }\n\n  update(id: string, input: Update${names.singularClassName}${typeSuffix}): ${names.singularClassName} | undefined {\n    const item = this.findOne(id);\n    if (!item) return undefined;\n    Object.assign(item, input);\n    return item;\n  }\n\n  remove(id: string): boolean {\n    const index = this.items.findIndex((item) => item.id === id);\n    if (index < 0) return false;\n    this.items.splice(index, 1);\n    return true;\n  }\n}\n`;
+}
+function renderCreateDto(names, suffix) {
+	const typeSuffix = pascalCase(suffix);
+	return `export class Create${names.singularClassName}${typeSuffix} {\n  name = "";\n}\n`;
+}
+function renderUpdateDto(names, suffix) {
+	const typeSuffix = pascalCase(suffix);
+	return `import type { Create${names.singularClassName}${typeSuffix} } from "./create-${names.singularFileName}.${suffix}.ts";\n\nexport type Update${names.singularClassName}${typeSuffix} = Partial<Create${names.singularClassName}${typeSuffix}>;\n`;
+}
+function renderEntity(names) {
+	return `export class ${names.singularClassName} {\n  id = "";\n  name = "";\n}\n`;
+}
+function renderResourceTransport(names, type, crud) {
+	const stem = resourceTransportStem(type);
+	const className = `${names.className}${pascalCase(stem)}`;
+	const method = crud ? `\n  findAll() {\n    return this.${names.propertyName}Service.findAll();\n  }\n` : "";
+	return `import { ${names.className}Service } from "./${names.fileName}.service.ts";\n\n/** ${type} transport scaffold. Connect this class to the matching Aponia platform package. */\nexport class ${className} {\n  constructor(private readonly ${names.propertyName}Service: ${names.className}Service) {}\n${method}}\n`;
+}
+function renderResourceServiceSpec(names) {
+	return `import { expect, test } from "bun:test";\nimport { ${names.className}Service } from "./${names.fileName}.service.ts";\n\ntest("${names.className}Service creates and returns resources", () => {\n  const service = new ${names.className}Service();\n  const created = service.create({ name: "sample" });\n  expect(service.findOne(created.id)).toEqual(created);\n});\n`;
+}
+function renderResourceTransportSpec(names, stem) {
+	const className = `${names.className}${pascalCase(stem)}`;
+	return `import { expect, test } from "bun:test";\nimport { ${className} } from "./${names.fileName}.${stem}.ts";\nimport { ${names.className}Service } from "./${names.fileName}.service.ts";\n\ntest("${className} is defined", () => {\n  expect(new ${className}(new ${names.className}Service())).toBeDefined();\n});\n`;
+}
+function classSuffix(schematic) {
+	if (schematic === "class" || schematic === "provider" || schematic === "interface") return "";
+	return pascalCase(schematic);
+}
+function symbolFor(schematic, names) {
+	if (schematic === "resource") return `${names.className}Module`;
+	return `${names.className}${classSuffix(schematic)}`;
+}
+function registrationFor(schematic) {
+	if (schematic === "resource") return "imports";
+	if (schematic === "app" || schematic === "library") return void 0;
+	return definitions[schematic].registration;
+}
+function primaryFile(files, schematic) {
+	const expectedSuffix = schematic === "resource" ? ".module.ts" : definitions[schematic].suffix ? `.${definitions[schematic].suffix}.ts` : ".ts";
+	return files.find((file) => file.path.endsWith(expectedSuffix) && !file.path.endsWith(".spec.ts"));
+}
+function resourceTransportStem(type) {
+	if (type === "ws") return "gateway";
+	if (type.startsWith("graphql")) return "resolver";
+	return "controller";
+}
+function createFile(directory, name, content) {
+	return {
+		path: join(directory, name),
+		content,
+		kind: "CREATE"
+	};
+}
+async function readConfiguration(projectRoot) {
+	const file = Bun.file(join(projectRoot, "aponia.json"));
+	if (!await file.exists()) throw new Error("Could not find \"aponia.json\". Run the command from an Aponia project root.");
+	return await file.json();
+}
+function resolveProject(configuration, requestedProject) {
+	if (!requestedProject) return {};
+	const project = configuration.projects?.[requestedProject];
+	if (!project) throw new Error(`Unknown project "${requestedProject}" in aponia.json.`);
+	return {
+		root: project.root,
+		sourceRoot: project.sourceRoot ?? join(project.root ?? "", "src"),
+		generateOptions: project.generateOptions
+	};
+}
+function readSpecDefault(value, schematic) {
+	if (typeof value === "boolean" || value === void 0) return value;
+	return value[schematic];
+}
+function resolveInside(root, path) {
+	const resolved = resolve(root, path);
+	if (resolved !== root && !resolved.startsWith(`${root}${sep}`)) throw new Error(`Path "${path}" escapes the project root.`);
+	return resolved;
+}
+async function findModuleFile(options) {
+	if (options.requestedModule) {
+		const candidates = await listModuleFiles(options.sourceRoot);
+		const normalized = options.requestedModule.replace(/\.module(?:\.ts)?$/, "");
+		const matches = candidates.filter((file) => {
+			const relativeFile = relative(options.sourceRoot, file).replaceAll("\\", "/");
+			return relativeFile === `${normalized}.module.ts` || relativeFile.endsWith(`/${normalized}.module.ts`);
+		});
+		if (matches.length !== 1) throw new Error(matches.length === 0 ? `Could not find module "${options.requestedModule}".` : `Module "${options.requestedModule}" is ambiguous.`);
+		return matches[0];
+	}
+	let directory = options.fromDirectory;
+	while (directory === options.sourceRoot || directory.startsWith(`${options.sourceRoot}${sep}`)) {
+		const modules = (await safeReadDirectory(directory)).filter((entry) => entry.endsWith(".module.ts")).map((entry) => join(directory, entry)).filter((file) => file !== options.excludedFile).toSorted();
+		if (modules.length > 0) return modules[0];
+		if (directory === options.sourceRoot) break;
+		directory = dirname(directory);
+	}
+}
+async function listModuleFiles(directory) {
+	return findFiles("**/*.module.ts", {
+		absolute: true,
+		cwd: directory,
+		onlyFiles: true
+	});
+}
+async function safeReadDirectory(directory) {
+	try {
+		return await readdir(directory);
+	} catch {
+		return [];
+	}
+}
+function toImportPath(moduleFile, generatedFile) {
+	let path = relative(dirname(moduleFile), generatedFile).replaceAll("\\", "/");
+	if (!path.startsWith(".")) path = `./${path}`;
+	return path;
+}
+//#endregion
 //#region src/index.ts
 async function runCli(arguments_) {
 	try {
@@ -94,6 +675,11 @@ async function runCli(arguments_) {
 			console.log(version);
 			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}`);
@@ -114,12 +700,34 @@ 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
 `;
 //#endregion
-export { generateProject, parseArguments, runCli };
+export { generateProject, generateSchematic, generateSchematics, parseArguments, runCli };