@ozanarslan/corpus-cli 0.0.1

package/dist/cli.mjs

@@ -0,0 +1,1448 @@
+#!/usr/bin/env bun
+import { C as LISTEN_PATTERN, D as NEVER_SCHEMAS, E as NAME_FLAG_HELP, O as PATTERNS, S as INTERFACE_MODEL_PATTERN, T as MODEL_TYPE_PATTERN, _ as isPresent, a as setLoggerNoop, b as EXE_NAME, c as quote, d as toPascalCase, f as assert, g as isObject, h as isEmpty, i as logger, l as toCamelCase, m as isAbsent, o as StringBuilder, r as logFatal, s as resolveCwdPath, t as getConfig, u as toKebabCase, v as isSomeArray, w as MODEL_PATTERN, x as GEN_FUNC, y as APP_NAME } from "./getConfig-lU3I2Ejy.mjs";
+import fs from "fs";
+import path from "path";
+import { parseSync } from "oxc-parser";
+import { createInterface } from "node:readline/promises";
+import { parseArgs } from "util";
+import { spawnSync } from "child_process";
+//#region src/internal/StringReader.ts
+var StringReader = class StringReader {
+	source;
+	constructor(source) {
+		this.source = source;
+		this.state = source;
+	}
+	state;
+	toString() {
+		return this.state;
+	}
+	resolveIndex(searchOrIndex) {
+		if (typeof searchOrIndex === "number") return searchOrIndex;
+		if (searchOrIndex instanceof RegExp) return this.state.search(searchOrIndex);
+		return this.state.indexOf(searchOrIndex);
+	}
+	resolveLineNumber(searchOrLine) {
+		if (typeof searchOrLine === "number") return searchOrLine;
+		const index = isObject(searchOrLine) ? searchOrLine.charIndex : this.resolveIndex(searchOrLine);
+		if (index === -1) return -1;
+		return this.state.slice(0, index).split("\n").length - 1;
+	}
+	static contains(text, search) {
+		return search instanceof RegExp ? search.test(text) : text.includes(search);
+	}
+	contains(search) {
+		return StringReader.contains(this.state, search);
+	}
+	containsAnyOf(...searches) {
+		return searches.some((search) => StringReader.contains(this.state, search));
+	}
+	containsAllOf(...searches) {
+		return searches.every((search) => StringReader.contains(this.state, search));
+	}
+	getSplitLines() {
+		return this.state.split("\n");
+	}
+	getLineNumberOfCharIndex(charIndex) {
+		return this.resolveLineNumber({ charIndex });
+	}
+	getLineNumber(search) {
+		return this.getSplitLines().findIndex((line) => StringReader.contains(line, search));
+	}
+	getLineNumberAfter(afterSearchOrLine, search) {
+		const afterLine = this.resolveLineNumber(afterSearchOrLine);
+		return this.getSplitLines().findIndex((line, index) => index > afterLine && StringReader.contains(line, search));
+	}
+	getLine(searchOrLine) {
+		const lineNumber = this.resolveLineNumber(searchOrLine);
+		return this.getSplitLines()[lineNumber] ?? "";
+	}
+	getLineOfCharIndex(charIndex) {
+		return this.getLine(this.getLineNumberOfCharIndex(charIndex));
+	}
+	getCharAt(charIndex) {
+		return this.state[charIndex] ?? null;
+	}
+	getBetween(start, end) {
+		const fromIndex = this.resolveIndex(start);
+		if (fromIndex === -1) return "";
+		const from = typeof start === "string" ? fromIndex + start.length : fromIndex;
+		const toIndex = this.state.indexOf(typeof end === "string" ? end : "", from);
+		if (toIndex === -1) return "";
+		return this.state.slice(from, typeof end === "number" ? end : toIndex).trim();
+	}
+	getFrom(startOrIndex) {
+		const index = this.resolveIndex(startOrIndex);
+		if (index === -1) return "";
+		const from = typeof startOrIndex === "string" ? index + startOrIndex.length : index;
+		return this.state.slice(from);
+	}
+	getUntil(endOrIndex) {
+		const index = this.resolveIndex(endOrIndex);
+		if (index === -1) return this.state;
+		return this.state.slice(0, index);
+	}
+	getLinesBetween(startSearchOrLine, endSearchOrLine) {
+		const fromLine = this.resolveLineNumber(startSearchOrLine);
+		const lines = this.getSplitLines();
+		const startLine = lines[fromLine] ?? "";
+		if (typeof endSearchOrLine === "string" && startLine.includes(endSearchOrLine)) return [];
+		const toLine = typeof endSearchOrLine === "number" ? endSearchOrLine : lines.findIndex((line, index) => index > fromLine && StringReader.contains(line, endSearchOrLine));
+		return lines.slice(fromLine + 1, toLine);
+	}
+	getLinesFrom(startSearchOrLine) {
+		const fromLine = this.resolveLineNumber(startSearchOrLine);
+		return this.getSplitLines().slice(fromLine);
+	}
+	getLinesUntil(endSearchOrLine) {
+		const toLine = this.resolveLineNumber(endSearchOrLine);
+		return this.getSplitLines().slice(0, toLine);
+	}
+	useBetween(start, end) {
+		return new StringReader(this.getBetween(start, end));
+	}
+	useFrom(startOrIndex) {
+		return new StringReader(this.getFrom(startOrIndex));
+	}
+	useUntil(endOrIndex) {
+		return new StringReader(this.getUntil(endOrIndex));
+	}
+	useLineOfCharIndex(charIndex) {
+		return new StringReader(this.getLine(this.getLineNumberOfCharIndex(charIndex)));
+	}
+	useLinesBetween(startSearchOrLine, endSearchOrLine) {
+		return new StringReader(this.getLinesBetween(startSearchOrLine, endSearchOrLine).join("\n"));
+	}
+	useLinesFrom(startSearchOrLine) {
+		return new StringReader(this.getLinesFrom(startSearchOrLine).join("\n"));
+	}
+	useLinesUntil(endSearchOrLine) {
+		return new StringReader(this.getLinesUntil(endSearchOrLine).join("\n"));
+	}
+	useLine(searchOrLine) {
+		return new StringReader(this.getLine(searchOrLine));
+	}
+	collapse() {
+		this.state = this.state.trim().replace(/\s+/g, " ");
+		return this;
+	}
+	replace(search, replacement) {
+		this.state = this.state.replace(search, replacement);
+		return this;
+	}
+	replaceAll(search, replacement) {
+		this.state = this.state.replaceAll(search, replacement);
+		return this;
+	}
+	replaceLine(searchOrLine, text) {
+		const lineNumber = this.resolveLineNumber(searchOrLine);
+		const lines = this.getSplitLines();
+		lines[lineNumber] = text;
+		this.state = lines.join("\n");
+		return this;
+	}
+	modifyLine(searchOrLine, modifier) {
+		const lineNumber = this.resolveLineNumber(searchOrLine);
+		const lines = this.getSplitLines();
+		lines[lineNumber] = modifier(lines[lineNumber] ?? "");
+		this.state = lines.join("\n");
+		return this;
+	}
+	addLine(text) {
+		this.state = this.state + "\n" + text;
+		return this;
+	}
+	addToLine(searchOrLine, text) {
+		const lineNumber = this.resolveLineNumber(searchOrLine);
+		const lines = this.getSplitLines();
+		lines[lineNumber] = lines[lineNumber] + text;
+		this.state = lines.join("\n");
+		return this;
+	}
+	getIndentation(line) {
+		const match = line.match(/^[\t ]*/);
+		return match ? match[0] : "";
+	}
+	indentText(text, indent) {
+		return text.split("\n").map((line) => line.length > 0 ? indent + line : line).join("\n");
+	}
+	addBelowLine(searchOrLine, text) {
+		const lineNumber = this.resolveLineNumber(searchOrLine);
+		const lines = this.getSplitLines();
+		const indent = this.getIndentation(lines[lineNumber] ?? "");
+		lines.splice(lineNumber + 1, 0, this.indentText(text, indent));
+		this.state = lines.join("\n");
+		return this;
+	}
+	addAboveLine(searchOrLine, text) {
+		const lineNumber = this.resolveLineNumber(searchOrLine);
+		const lines = this.getSplitLines();
+		const indent = this.getIndentation(lines[lineNumber] ?? "");
+		lines.splice(lineNumber, 0, this.indentText(text, indent));
+		this.state = lines.join("\n");
+		return this;
+	}
+};
+//#endregion
+//#region src/FileParser/index.ts
+var FileParser = class {
+	filePath;
+	constructor(filePath) {
+		this.filePath = filePath;
+		this.reload();
+	}
+	reload() {
+		this._contents = this.initFileContent();
+		this._reader = this.initReader();
+		this._program = this.initProgram();
+	}
+	initFileContent() {
+		return fs.readFileSync(this.filePath, "utf8");
+	}
+	initReader() {
+		return new StringReader(this.contents);
+	}
+	initProgram() {
+		const { program, errors } = parseSync(this.filePath, this.contents, { sourceType: "module" });
+		if (errors.length > 0) {
+			logger.error("Parse errors:");
+			for (const err of errors) logger.error(err);
+			process.exit(1);
+		}
+		return program;
+	}
+	_reader;
+	get reader() {
+		if (isAbsent(this._reader)) this._reader = this.initReader();
+		return this._reader;
+	}
+	_contents;
+	get contents() {
+		if (isAbsent(this._contents)) this._contents = this.initFileContent();
+		return this._contents;
+	}
+	_program;
+	get program() {
+		if (isAbsent(this._program)) this._program = this.initProgram();
+		return this._program;
+	}
+	flushReader() {
+		fs.writeFileSync(this.filePath, this.reader.toString());
+		this.reload();
+	}
+	getNodeTextContent(node) {
+		return this.reader.getBetween(node.start, node.end);
+	}
+	runCallbackOn(node, cb) {
+		this.handleNode(node, cb);
+	}
+	runCallback(cb) {
+		this.handleNode(this.program, cb);
+	}
+	handleNode(input, cb) {
+		if (typeof input !== "object") return;
+		if (input === null) return;
+		if (!("start" in input)) return;
+		if (typeof input.start !== "number") return;
+		if (!("end" in input)) return;
+		if (typeof input.end !== "number") return;
+		if (!("type" in input)) return;
+		if (typeof input.type !== "string") return;
+		const node = input;
+		const result = cb(node, this.reader);
+		const nextCb = typeof result === "function" ? result : cb;
+		if (node.type === "ExportDefaultDeclaration" || node.type === "ExportNamedDeclaration") {
+			if (node.declaration?.type) node.type = node.declaration?.type;
+		}
+		for (const inner of Object.values(node)) if (Array.isArray(inner)) for (const ii of inner) this.handleNode(ii, nextCb);
+		else this.handleNode(inner, nextCb);
+	}
+};
+//#endregion
+//#region src/FileParser/MainFileUpdater.ts
+const above = (kind) => ({
+	at: "above",
+	kind
+});
+const below = (kind) => ({
+	at: "below",
+	kind
+});
+const PLACES_BY_KIND = {
+	import: [above("import")],
+	route: [
+		below("route"),
+		above("controller"),
+		above("middleware"),
+		below("service")
+	],
+	middleware: [
+		below("middleware"),
+		below("controller"),
+		below("route"),
+		below("service")
+	],
+	controller: [
+		below("controller"),
+		below("route"),
+		above("middleware"),
+		below("service")
+	],
+	service: [
+		below("service"),
+		above("controller"),
+		above("route"),
+		above("middleware")
+	]
+};
+var MainFileUpdater = class {
+	constructor() {
+		this.filePath = getConfig().main;
+	}
+	filePath;
+	set = /* @__PURE__ */ new Set();
+	reader;
+	reload() {
+		this.set.clear();
+		new FileParser(this.filePath).runCallback((node, reader) => {
+			this.reader = reader;
+			this.processNode(node);
+		});
+	}
+	flush() {
+		fs.writeFileSync(this.filePath, this.reader.toString());
+		this.reload();
+	}
+	addLines(kind, ...lines) {
+		this.reload();
+		lines = lines.filter((line) => {
+			const match = this.reader.getLine(line.trim());
+			const pass = isEmpty(match);
+			if (!pass) logger.warn(`Skipping existing line: ${line}`);
+			return pass;
+		});
+		if (!isSomeArray(lines)) return;
+		const place = this.getPlace(kind);
+		if (place.at === "below") this.reader.addBelowLine(place.line, lines.join("\n"));
+		else this.reader.addAboveLine(place.line, lines.join("\n"));
+		this.flush();
+	}
+	getKind(line) {
+		for (const kind of Object.keys(PATTERNS)) if (PATTERNS[kind].test(line)) return kind;
+		return null;
+	}
+	getPlace(kind) {
+		const places = PLACES_BY_KIND[kind];
+		let index = null;
+		let at = "below";
+		let i = 0;
+		while (isAbsent(index) && i < places.length) {
+			const place = places[i];
+			if (place) {
+				at = place.at;
+				if (place.at === "below") index = this.getChunkEnd(place.kind);
+				else index = this.getChunkStart(place.kind);
+			}
+			i++;
+		}
+		if (isPresent(index)) return {
+			at,
+			line: this.reader.getLineNumberOfCharIndex(index)
+		};
+		if (kind === "import") return {
+			at: "above",
+			line: 0
+		};
+		return {
+			at: "above",
+			line: this.reader.getLineNumber(LISTEN_PATTERN)
+		};
+	}
+	getChunkStart(kind) {
+		const vals = Array.from(this.set).filter((it) => it.kind === kind).map((it) => it.start);
+		if (!isSomeArray(vals)) return null;
+		return Math.min(...vals);
+	}
+	getChunkEnd(kind) {
+		const vals = Array.from(this.set).filter((it) => it.kind === kind).map((it) => it.end);
+		if (!isSomeArray(vals)) return null;
+		return Math.max(...vals);
+	}
+	processNode(node) {
+		switch (node.type) {
+			case "ImportDeclaration":
+				this.set.add({
+					kind: "import",
+					text: this.reader.getBetween(node.start, node.end),
+					start: node.start,
+					end: node.end
+				});
+				break;
+			case "ExpressionStatement":
+			case "VariableDeclaration": for (const [kind, pattern] of Object.entries(PATTERNS)) {
+				if (kind === "import") continue;
+				const content = this.reader.useBetween(node.start, node.end);
+				if (content.useLine(0).contains(pattern)) this.set.add({
+					kind,
+					text: content.toString(),
+					start: node.start,
+					end: node.end
+				});
+			}
+		}
+	}
+};
+//#endregion
+//#region src/Config/getTsConfig.ts
+function getTsConfig() {
+	const tsconfigPath = resolveCwdPath("tsconfig.json");
+	if (!fs.existsSync(tsconfigPath)) {
+		logger.log(`No tsconfig.json found.`);
+		return null;
+	}
+	return JSON.parse(fs.readFileSync(tsconfigPath, "utf-8"));
+}
+//#endregion
+//#region src/Importable/index.ts
+var Importable = class {
+	resourceName;
+	kind;
+	constructor(resourceName, kind) {
+		this.resourceName = resourceName;
+		this.kind = kind;
+		this.config = getConfig();
+		this.targetDirPath = this.resolveTargetDir();
+	}
+	config;
+	targetDirPath;
+	get name() {
+		return `${this.resourceName}-${this.kind}`;
+	}
+	get pascalName() {
+		return toPascalCase(this.name);
+	}
+	get camelName() {
+		return toCamelCase(this.name);
+	}
+	get filePath() {
+		const relPath = (this.config.folderStructure?.[this.kind] ?? "{resource}/{resource}-{kind}.ts").replaceAll("{resource}", this.resourceName).replaceAll("{kind}", this.kind).split("/").map((segment) => {
+			const ext = path.extname(segment);
+			const base = ext ? segment.slice(0, -ext.length) : segment;
+			return this.convertCase(base) + ext;
+		}).join("/");
+		return path.join(path.relative(process.cwd(), this.targetDirPath), relPath);
+	}
+	parseFile(cb) {
+		return new FileParser(this.filePath).runCallback(cb);
+	}
+	importFrom(inFile) {
+		const alias = this.resolveAliasFor(this.filePath);
+		if (alias) return alias;
+		const rel = path.relative(path.dirname(inFile), this.filePath).replace(/\.ts$/, "");
+		return rel.startsWith(".") ? rel : `./${rel}`;
+	}
+	resolveAliasFor(filePath) {
+		const tsconfig = getTsConfig();
+		if (!tsconfig) return null;
+		const paths = tsconfig.compilerOptions?.paths ?? {};
+		const fileNoExt = filePath.replace(/\.ts$/, "").replace(/^\.\//, "");
+		let bestAlias = null;
+		let bestTargetLen = -1;
+		for (const [alias, targets] of Object.entries(paths)) {
+			const targetDir = (targets[0] ?? "").replace(/\/\*$/, "").replace(/^\.\//, "");
+			if (!fileNoExt.startsWith(targetDir)) continue;
+			if (targetDir.length <= bestTargetLen) continue;
+			bestTargetLen = targetDir.length;
+			const aliasPrefix = alias.replace(/\/\*$/, "");
+			const rest = fileNoExt.slice(targetDir.length).replace(/^\//, "");
+			bestAlias = rest ? `${aliasPrefix}/${rest}` : aliasPrefix;
+		}
+		return bestAlias;
+	}
+	resolveTargetDir() {
+		const mainPath = resolveCwdPath(this.config.main);
+		if (!fs.existsSync(mainPath)) logFatal(`Could not find main file at ${mainPath}.`);
+		return path.dirname(mainPath);
+	}
+	convertCase(s) {
+		switch (this.config.casing) {
+			case "pascal":
+			default: return toPascalCase(s);
+			case "camel": return toCamelCase(s);
+			case "kebab": return toKebabCase(s);
+		}
+	}
+};
+//#endregion
+//#region src/internal/parseModelDefinition.ts
+function parseModelDefinition(model) {
+	let modelName = "";
+	let modelTypeName = "";
+	const modelDef = {};
+	model.parseFile((node, reader) => {
+		const firstLn = reader.useBetween(node.start, node.end).useUntil("\n");
+		const isModel = firstLn.contains(MODEL_PATTERN);
+		function str(node) {
+			return reader.getBetween(node.start, node.end);
+		}
+		if (isModel) {
+			if (node.type === "ClassDeclaration") {
+				modelName = node.id?.name ?? "";
+				for (const member of node.body.body) if (member.type === "MethodDefinition" && member.static && member.kind === "get") {
+					const returns = member.value.body?.body.find((b) => b.type === "ReturnStatement");
+					if (returns?.argument?.type !== "ObjectExpression") continue;
+					modelDef[str(member.key)] = {};
+					for (const prop of returns.argument.properties) {
+						if (prop.type === "SpreadElement") continue;
+						if (prop.value) modelDef[str(member.key)][str(prop.key)] = str(prop.value);
+					}
+				} else if (member.type === "PropertyDefinition" && member.static) {
+					if (member.value?.type !== "ObjectExpression") continue;
+					modelDef[str(member.key)] = {};
+					for (const prop of member.value.properties) {
+						if (prop.type === "SpreadElement") continue;
+						if (prop.value) modelDef[str(member.key)][str(prop.key)] = str(prop.value);
+					}
+				}
+			} else if (node.type === "VariableDeclaration") {
+				const decl = node.declarations.find((decl) => decl.init?.type === "ObjectExpression");
+				if (decl?.id.type === "Identifier") modelName = decl.id.name;
+				const obj = decl?.init;
+				if (!obj || obj.type !== "ObjectExpression") return;
+				for (const prop of obj.properties) {
+					if (prop.type === "SpreadElement") continue;
+					if (prop.value?.type !== "ObjectExpression") continue;
+					modelDef[str(prop.key)] = {};
+					for (const prop2 of prop.value.properties) {
+						if (prop2.type === "SpreadElement") continue;
+						if (prop2.value) modelDef[str(prop.key)][str(prop2.key)] = str(prop2.value);
+					}
+				}
+			}
+		}
+		if (firstLn.contains(MODEL_TYPE_PATTERN)) modelTypeName = firstLn.toString().match(MODEL_TYPE_PATTERN)?.[1] ?? "";
+		if (node.type === "TSInterfaceDeclaration") {
+			const match = firstLn.toString().match(INTERFACE_MODEL_PATTERN);
+			if (match?.[1]) {
+				modelTypeName = match[1];
+				for (const member of node.body.body) {
+					if (member.type !== "TSPropertySignature") continue;
+					if (!member.typeAnnotation) continue;
+					const key = str(member.key);
+					const typeNode = member.typeAnnotation.typeAnnotation;
+					if (typeNode.type !== "TSTypeLiteral") continue;
+					modelDef[key] = {};
+					for (const inner of typeNode.members) {
+						if (inner.type !== "TSPropertySignature") continue;
+						if (!inner.typeAnnotation) continue;
+						const innerKey = str(inner.key);
+						modelDef[key][innerKey] = str(inner.typeAnnotation.typeAnnotation);
+					}
+				}
+			}
+		}
+	});
+	return {
+		modelName,
+		modelTypeName,
+		modelDef
+	};
+}
+//#endregion
+//#region src/Modules/ModuleAbstract.ts
+var ModuleAbstract = class {
+	constructor() {
+		this.config = getConfig();
+	}
+	config;
+	flags = {
+		name: null,
+		empty: false
+	};
+	passedKey = "";
+	messages = [];
+	addMessage(msg) {
+		this.messages.push(msg);
+	}
+	async run() {
+		const shutdown = async (code, err) => {
+			await this.stop();
+			if (err) logger.error(String(err));
+			process.exit(code);
+		};
+		process.once("SIGINT", () => void shutdown(130));
+		process.once("SIGTERM", () => void shutdown(143));
+		process.once("uncaughtException", (err) => void shutdown(1, err));
+		process.once("unhandledRejection", (err) => void shutdown(1, err));
+		this.parseFlags();
+		logger.info(`Running: ${this.passedKey}`);
+		if (this.config.silent) setLoggerNoop();
+		await this.main();
+	}
+	stopped = false;
+	async stop() {
+		logger.info(`Stopping: ${this.passedKey}`);
+		if (this.stopped) return;
+		this.stopped = true;
+		for (const msg of this.messages) logger.warn(msg);
+	}
+	printHelp(exitCode) {
+		process.stdout.write(this.help.join("\n"));
+		process.exit(exitCode);
+	}
+	parseFlags() {
+		this.passedKey = process.argv.slice(2)[0] ?? "";
+		const { values, positionals } = parseArgs({
+			args: process.argv.slice(3),
+			options: {
+				help: {
+					type: "boolean",
+					short: "h"
+				},
+				main: {
+					type: "string",
+					short: "m"
+				},
+				silent: {
+					type: "boolean",
+					short: "s",
+					default: false
+				},
+				name: {
+					type: "string",
+					short: "n"
+				},
+				output: {
+					type: "string",
+					short: "o"
+				},
+				empty: {
+					type: "boolean",
+					short: "e",
+					default: false
+				}
+			},
+			allowPositionals: true
+		});
+		if (values.help) this.printHelp(0);
+		this.flags.name = values.name ?? positionals[0] ?? null;
+		this.flags.empty = values.empty;
+		if (isPresent(values.silent)) this.config.silent = values.silent;
+		if (isPresent(values.main)) this.config.main = values.main;
+		if (isPresent(values.output)) this.config.output = values.output;
+	}
+	async promptConfirm(question) {
+		const rl = createInterface({
+			input: process.stdin,
+			output: process.stdout
+		});
+		const answer = await rl.question(question + " (y/n) ");
+		rl.close();
+		const confirmed = /^y(es)?$/i.test(answer.trim());
+		if (!confirmed) process.exit(0);
+		return confirmed;
+	}
+	readFile(segments) {
+		try {
+			return fs.readFileSync(resolveCwdPath(...segments), "utf8");
+		} catch {
+			return "";
+		}
+	}
+	checkFileExists(segments) {
+		return fs.existsSync(resolveCwdPath(...segments));
+	}
+	writeFile(content, segments) {
+		return this.writeToAbsolutePath(content, resolveCwdPath(...segments));
+	}
+	writeToAbsolutePath(content, absPath) {
+		const exists = fs.existsSync(absPath);
+		const cleanPath = absPath.replace(process.cwd(), "");
+		if (exists) {
+			logger.warn(`NOT WRITTEN: File exists at ${cleanPath}.`);
+			return;
+		}
+		fs.mkdirSync(path.dirname(absPath), { recursive: true });
+		fs.writeFileSync(absPath, content);
+		logger.info(`Writing file: ${cleanPath}`);
+	}
+};
+//#endregion
+//#region src/Modules/AddControllerModule.ts
+var AddControllerModule = class extends ModuleAbstract {
+	mainFileUpdater;
+	constructor(mainFileUpdater) {
+		super();
+		this.mainFileUpdater = mainFileUpdater;
+	}
+	keys = ["controller", "ctrl"];
+	get help() {
+		return [
+			"Scaffold a standalone controller with stubbed CRUD routes.",
+			"",
+			`Usage: ${EXE_NAME} ${this.keys.join("|")} ${NAME_FLAG_HELP}`,
+			"",
+			"Options:",
+			`  ${NAME_FLAG_HELP}   Name of the controller to generate.`,
+			"",
+			"Note: this only generates the controller file. Without a matching",
+			"model and service, the stubbed routes will be untyped and just throw."
+		];
+	}
+	main() {
+		const name = this.flags.name;
+		assert(name, `name is required.\n\t${EXE_NAME} ${this.passedKey} ${NAME_FLAG_HELP}`);
+		const controller = new Importable(name, "controller");
+		const model = new Importable(name, "model");
+		const service = new Importable(name, "service");
+		this.writeFile(this.buildControllerFile(controller, model, service), [controller.filePath]);
+		this.mainFileUpdater.addLines("import", `import { ${controller.pascalName} } from "${controller.importFrom(this.config.main)}";`);
+		this.mainFileUpdater.addLines("controller", `new ${controller.pascalName}(${service.camelName});`);
+	}
+	buildControllerFile(controller, model, service) {
+		const modelExists = fs.existsSync(model.filePath);
+		const serviceExists = fs.existsSync(service.filePath);
+		if (modelExists && serviceExists) return this.buildControllerFileWithModel(controller, model, service);
+		if (this.flags.empty) return this.buildEmptyControllerFile(controller);
+		return this.buildControllerFileWithDefaults(controller);
+	}
+	buildEmptyControllerFile(controller) {
+		const b = new StringBuilder();
+		b.line(`import { C } from "${this.config.pkgPath}";`);
+		b.line("");
+		b.line(`export class ${controller.pascalName} extends C.Controller {`);
+		b.line(1)(`constructor(private readonly service: unknown) {`);
+		b.line(2)(`super();`);
+		b.line(1)(`}`);
+		b.line("");
+		b.line(1)(`override prefix = "/${controller.resourceName}";`);
+		b.line(`}`);
+		return b.toString();
+	}
+	buildControllerFileWithDefaults(controller) {
+		const b = new StringBuilder();
+		const methods = this.config.defaultMethods;
+		b.line(`import { C } from "${this.config.pkgPath}";`);
+		b.line("");
+		b.line(`export class ${controller.pascalName} extends C.Controller {`);
+		b.line(1)(`constructor(private readonly service: unknown) {`);
+		b.line(2)(`super();`);
+		b.line(1)(`}`);
+		b.line("");
+		b.line(1)(`override prefix = "/${controller.resourceName}";`);
+		for (const { propertyKey, address } of Object.values(methods)) {
+			b.line("");
+			b.line(1)(`${propertyKey} = this.route(${quote(address)}, (c) => { throw new Error("Method not implemented."); });`);
+		}
+		b.line(`}`);
+		return b.toString();
+	}
+	buildControllerFileWithModel(controller, model, service) {
+		const b = new StringBuilder();
+		const { modelName, modelTypeName, modelDef } = parseModelDefinition(model);
+		const noValLib = isAbsent(this.config.validationLibrary);
+		b.line(`import { C } from "${this.config.pkgPath}";`);
+		b.line(`import ${noValLib ? "type " : ""}{ ${noValLib ? modelTypeName : modelName} } from "${model.importFrom(controller.filePath)}";`);
+		b.line(`import { ${service.pascalName} } from "${service.importFrom(controller.filePath)}";`);
+		b.line("");
+		b.line(`export class ${controller.pascalName} extends C.Controller {`);
+		b.line(1)(`constructor(private readonly service: ${service.pascalName}) {`);
+		b.line(2)(`super();`);
+		b.line(1)(`}`);
+		b.line("");
+		b.line(1)(`override prefix = "/${controller.resourceName}";`);
+		for (const [key, val] of Object.entries(modelDef)) {
+			const ORDER = [
+				"body",
+				"search",
+				"params",
+				"response"
+			];
+			const callArgs = [
+				"search",
+				"params",
+				"body"
+			].filter((k) => k in val && !this.isNeverSchema(val[k])).map((k) => `c.${k}`).join(", ");
+			const generics = noValLib ? `<${ORDER.map((acc) => `\n\t\t${modelTypeName}["${key}"]["${acc}"]`).join(",")}\n\t>` : "";
+			const address = this.resolveAddress(val);
+			const baseArgs = `${quote(address)}, (c) => this.service.${key}(${callArgs})`;
+			const validatorArg = noValLib ? "" : `, ${modelName}.${key}`;
+			b.line("");
+			b.line(1)(`${key} = this.route${generics}(${baseArgs}${validatorArg});`);
+		}
+		b.line(`}`);
+		return b.toString();
+	}
+	isNeverSchema = (schema) => NEVER_SCHEMAS.has(schema.trim());
+	hasSchema(model, key) {
+		return key in model && typeof model[key] === "string" && !NEVER_SCHEMAS.has(model[key].trim());
+	}
+	resolveAddress(model) {
+		let method = "GET";
+		let endpoint = "/";
+		const hasBody = this.hasSchema(model, "body");
+		const hasParams = this.hasSchema(model, "params");
+		if (hasBody && hasParams) method = "PUT";
+		else if (hasBody && !hasParams) method = "POST";
+		else if (!hasBody && hasParams) method = "DELETE";
+		if (hasParams && typeof model.params === "string") {
+			const keys = this.extractParamKeys(model.params);
+			if (keys.length > 0) endpoint = "/" + keys.map((k) => `:${k}`).join("/");
+		}
+		return `${method} ${endpoint}`;
+	}
+	extractParamKeys(paramsStr) {
+		const keyRegex = /["']?([A-Za-z_$][A-Za-z0-9_$]*)["']?\s*:/g;
+		const keys = [];
+		let match;
+		while ((match = keyRegex.exec(paramsStr)) !== null) if (!isAbsent(match[1])) keys.push(match[1]);
+		return keys;
+	}
+};
+//#endregion
+//#region src/Modules/AddExceptionModule.ts
+var AddExceptionModule = class extends ModuleAbstract {
+	keys = ["exception", "exc"];
+	get help() {
+		return [
+			"Scaffold a standalone exception class with a default NotImplemented exception.",
+			"",
+			`Usage: ${EXE_NAME} ${this.keys.join("|")} ${NAME_FLAG_HELP}`,
+			"",
+			"Options:",
+			`  ${NAME_FLAG_HELP}   Name of the exception class to generate.`,
+			"  --empty             Generate a bare exception class with no default exceptions.",
+			"",
+			"Note: this only generates the exception file and does not touch any other files."
+		];
+	}
+	main() {
+		const name = this.flags.name;
+		assert(name, `name is required.\n\t${EXE_NAME} ${this.passedKey} ${NAME_FLAG_HELP}`);
+		const exception = new Importable(name, "exception");
+		this.writeFile(this.buildExceptionFile(exception), [exception.filePath]);
+	}
+	buildExceptionFile(exception) {
+		if (this.flags.empty) return this.buildEmptyExceptionFile(exception);
+		return this.buildExceptionFileWithDefaults(exception);
+	}
+	buildEmptyExceptionFile(exception) {
+		const b = new StringBuilder();
+		b.line(`export class ${exception.pascalName} {`);
+		b.line(`}`);
+		return b.toString();
+	}
+	buildExceptionFileWithDefaults(exception) {
+		const b = new StringBuilder();
+		b.line(`import { C } from ${quote(this.config.pkgPath)};`);
+		b.line("");
+		b.line(`export class ${exception.pascalName} {`);
+		b.line(1)(`static NotImplemented = new C.Exception("NotImplemented", C.Status.INTERNAL_SERVER_ERROR);`);
+		b.line(`}`);
+		return b.toString();
+	}
+};
+//#endregion
+//#region src/Modules/AddModelModule.ts
+var AddModelModule = class extends ModuleAbstract {
+	keys = ["model", "mdl"];
+	get help() {
+		return [
+			"Scaffold a standalone model with a default CRUD-shaped interface or schema.",
+			"",
+			`Usage: ${EXE_NAME} ${this.keys.join("|")} ${NAME_FLAG_HELP}`,
+			"",
+			"Options:",
+			`  ${NAME_FLAG_HELP}   Name of the model to generate.`,
+			"  --empty             Generate a bare model with no default CRUD shape.",
+			"",
+			"Note: this only generates the model file and does not touch any other files."
+		];
+	}
+	main() {
+		const name = this.flags.name;
+		assert(name, `name is required.\n\t${EXE_NAME} ${this.passedKey} ${NAME_FLAG_HELP}`);
+		const model = new Importable(name, "model");
+		const modelTypeName = `${model.pascalName}Type`;
+		this.writeFile(this.buildModelFile(model, modelTypeName), [model.filePath]);
+	}
+	buildModelFile(model, modelTypeName) {
+		if (this.flags.empty) return this.buildEmptyModelFile(model);
+		return this.buildModelFileWithDefaults(model, modelTypeName);
+	}
+	buildEmptyModelFile(model) {
+		const b = new StringBuilder();
+		b.line(`export interface ${model.pascalName}Type {`);
+		b.line(1)(`entity: {`);
+		b.line(2)(`id: string;`);
+		b.line(1)(`};`);
+		b.line(`}`);
+		return b.toString();
+	}
+	buildModelFileWithDefaults(model, modelTypeName) {
+		const ms = this.config.defaultMethods;
+		const validationLibrary = this.config.validationLibrary;
+		const type = (methodKey, ...accessors) => {
+			const key = methodKey === "entity" ? "entity" : ms[methodKey].propertyKey;
+			return `${modelTypeName}[${quote(key)}]${accessors.map((accessor) => `[${quote(accessor)}]`).join("")}`;
+		};
+		if (isAbsent(validationLibrary)) return `export interface ${modelTypeName} {
+    entity: {
+        id: string;
+        name: string;
+    };
+
+    ${ms.get.propertyKey}: {
+        search: {
+            page?: number;
+            limit?: number;
+        };
+        response: {
+            data: Array<${type("entity")}>;
+            page: number;
+            limit: number;
+            count: number;
+            totalCount: number;
+            pageCount: number;
+        };
+        params: never;
+        body: never;
+    };
+
+    ${ms.getByParams.propertyKey}: {
+        params: {
+            id: string;
+        };
+        response: ${type("entity")};
+        search: never;
+        body: never;
+    };
+
+    ${ms.create.propertyKey}: {
+        body: {
+            name: string;
+        };
+        response: ${type("entity")};
+        search: never;
+        params: never;
+    }
+
+    ${ms.update.propertyKey}: {
+        body: Partial<${type("create", "body")}>;
+        response: ${type("entity")};
+        params: ${type("getByParams", "params")};
+        search: never;
+    };
+
+    ${ms.remove.propertyKey}: {
+        params: ${type("getByParams", "params")};
+        response: void;
+        body: never;
+        search: never;
+    };
+};`;
+		const schemas = this.getSchemas(validationLibrary);
+		return `${schemas.import}
+import type { C } from ${quote(this.config.pkgPath)};
+
+export type ${modelTypeName} = C.InferModel<typeof ${model.pascalName}>
+
+export abstract class ${model.pascalName} {${validationLibrary === "yup" ? `\n\tstatic readonly never = y.mixed().oneOf([undefined] as const);\n` : ``}
+    static readonly entity = ${schemas.entity};
+
+    static readonly ${ms.get.propertyKey} = ${schemas.get};
+
+    static readonly ${ms.getByParams.propertyKey} = ${schemas.getByParams};
+
+    static readonly ${ms.create.propertyKey} = ${schemas.create};
+
+    static readonly ${ms.update.propertyKey} = ${schemas.update};
+
+    static readonly ${ms.remove.propertyKey} = ${schemas.remove};
+}`;
+	}
+	getSchemas(validationLibrary) {
+		switch (validationLibrary) {
+			case "zod": return {
+				import: `import * as z from "zod";`,
+				entity: `z.object({
+		id: z.string(),
+		name: z.string(),
+	})`,
+				get: `{
+		body: z.never(),
+		search: z.object({
+			page: z.number().optional(),
+			limit: z.number().optional(),
+		}),
+		params: z.never(),
+		response: z.object({
+			data: z.array(this.entity),
+			page: z.number(),
+			limit: z.number(),
+			count: z.number(),
+			totalCount: z.number(),
+			pageCount: z.number(),
+		}),
+	}`,
+				getByParams: `{
+		body: z.never(),
+		search: z.never(),
+		params: z.object({
+			id: z.string(),
+		}),
+		response: this.entity,
+	}`,
+				create: `{
+		body: z.object({
+			name: z.string(),
+		}),
+		search: z.never(),
+		params: z.never(),
+		response: this.entity,
+	}`,
+				update: `{
+		body: this.create.body.partial(),
+		search: z.never(),
+		params: this.getByParams.params,
+		response: this.entity,
+	}`,
+				remove: `{
+		body: z.never(),
+		search: z.never(),
+		params: this.getByParams.params,
+		response: z.void(),
+	}`
+			};
+			case "yup": return {
+				import: `import * as y from "yup";`,
+				entity: `y.object({
+		id: y.string().required(),
+		name: y.string().required(),
+	})`,
+				get: `{
+		body: this.never,
+		search: y.object({
+			page: y.number().optional(),
+			limit: y.number().optional(),
+		}),
+		params: this.never,
+		response: y.object({
+			data: y.array(this.entity).required(),
+			page: y.number().required(),
+			limit: y.number().required(),
+			count: y.number().required(),
+			totalCount: y.number().required(),
+			pageCount: y.number().required(),
+		}),
+	}`,
+				getByParams: `{
+		body: this.never,
+		search: this.never,
+		params: y.object({
+			id: y.string().required(),
+		}),
+		response: this.entity,
+	}`,
+				create: `{
+		body: y.object({
+			name: y.string().required(),
+		}),
+		search: this.never,
+		params: this.never,
+		response: this.entity,
+	}`,
+				update: `{
+		body: this.create.body.partial(),
+		search: this.never,
+		params: this.getByParams.params,
+		response: this.entity,
+	}`,
+				remove: `{
+		body: this.never,
+		search: this.never,
+		params: this.getByParams.params,
+		response: undefined,
+	}`
+			};
+			case "arktype": return {
+				import: `import { type } from "arktype";`,
+				entity: `type({
+		id: "string",
+		name: "string",
+	})`,
+				get: `{
+		body: type("never"),
+		search: type({
+			"page?": "number",
+			"limit?": "number",
+		}),
+		params: type("never"),
+		response: type({
+			data: this.entity.array(),
+			page: type("number"),
+			limit: type("number"),
+			count: type("number"),
+			totalCount: type("number"),
+			pageCount: type("number"),
+		}),
+	}`,
+				getByParams: `{
+		body: type("never"),
+		search: type("never"),
+		params: type({
+			id: type("string"),
+		}),
+		response: this.entity,
+	}`,
+				create: `{
+		body: type({
+			name: type("string"),
+		}),
+		search: type("never"),
+		params: type("never"),
+		response: this.entity,
+	}`,
+				update: `{
+		body: this.create.body.partial(),
+		search: type("never"),
+		params: this.getByParams.params,
+		response: this.entity,
+	}`,
+				remove: `{
+		body: type("never"),
+		search: type("never"),
+		params: this.getByParams.params,
+	}`
+			};
+		}
+	}
+};
+//#endregion
+//#region src/Resource/index.ts
+var Resource = class {
+	constructor(key) {
+		this.config = getConfig();
+		this.pascalName = toPascalCase(key);
+		this.camelName = toCamelCase(key);
+		this.kebabName = toKebabCase(key);
+		this.model = new Importable(key, "model");
+		this.modelTypeName = `${this.model.pascalName}Type`;
+		this.service = new Importable(key, "service");
+		this.controller = new Importable(key, "controller");
+		this.exception = new Importable(key, "exception");
+	}
+	config;
+	pascalName;
+	camelName;
+	kebabName;
+	model;
+	modelTypeName;
+	service;
+	controller;
+	exception;
+	type(methodKey, ...accessors) {
+		const ms = this.config.defaultMethods;
+		return `${this.modelTypeName}[${quote(methodKey === "entity" ? "entity" : ms[methodKey].propertyKey)}]${accessors.map((accessor) => `[${quote(accessor)}]`)}`;
+	}
+	route(methodKey, body) {
+		const ms = this.config.defaultMethods;
+		const noValLib = isAbsent(this.config.validationLibrary);
+		const generics = noValLib ? `<${[
+			"body",
+			"search",
+			"params",
+			"response"
+		].map((acc) => `\n\t\t${this.type(methodKey, acc)}`).join(",")}\n\t>` : ``;
+		const baseArgs = `${quote(ms[methodKey].address)}, ${body}`;
+		return `${ms[methodKey].propertyKey} = this.route${generics}(${baseArgs}${noValLib ? `` : `, ${this.model.pascalName}.${ms[methodKey].propertyKey}`})`;
+	}
+};
+//#endregion
+//#region src/Modules/AddResourceModule.ts
+var AddResourceModule = class extends ModuleAbstract {
+	mainFileUpdater;
+	addModelModule;
+	addExceptionModule;
+	addServiceModule;
+	addControllerModule;
+	constructor(mainFileUpdater, addModelModule, addExceptionModule, addServiceModule, addControllerModule) {
+		super();
+		this.mainFileUpdater = mainFileUpdater;
+		this.addModelModule = addModelModule;
+		this.addExceptionModule = addExceptionModule;
+		this.addServiceModule = addServiceModule;
+		this.addControllerModule = addControllerModule;
+	}
+	keys = ["resource", "res"];
+	get help() {
+		return [
+			"Scaffold a new resource (model, service, controller, exception).",
+			"",
+			`Usage: ${EXE_NAME} ${this.keys.join("|")} ${NAME_FLAG_HELP}`,
+			"",
+			"Options:",
+			`  ${NAME_FLAG_HELP}   Name of the resource to generate.`,
+			"  --empty             Generate a bare model with no default CRUD shape."
+		];
+	}
+	main() {
+		const name = this.flags.name;
+		assert(name, `name is required.\n\t${EXE_NAME} ${this.passedKey} ${NAME_FLAG_HELP}`);
+		const r = new Resource(name);
+		this.writeFile(this.addModelModule.buildModelFile(r.model, r.modelTypeName), [r.model.filePath]);
+		this.writeFile(this.addExceptionModule.buildExceptionFile(r.exception), [r.exception.filePath]);
+		this.writeFile(this.addServiceModule.buildServiceFile(r.service, r.model, r.exception), [r.service.filePath]);
+		this.writeFile(this.addControllerModule.buildControllerFile(r.controller, r.model, r.service), [r.controller.filePath]);
+		this.mainFileUpdater.addLines("import", `import { ${r.service.pascalName} } from ${quote(r.service.importFrom(this.config.main))};`, `import { ${r.controller.pascalName} } from ${quote(r.controller.importFrom(this.config.main))};`);
+		this.mainFileUpdater.addLines("service", `const ${r.service.camelName} = new ${r.service.pascalName}();`);
+		this.mainFileUpdater.addLines("controller", `new ${r.controller.pascalName}(${r.service.camelName});`);
+	}
+};
+//#endregion
+//#region src/internal/checkNotImplementedExceptionExists.ts
+function checkNotImplementedExceptionExists(exception) {
+	let notImplementedExceptionExists = false;
+	if (fs.existsSync(exception.filePath)) exception.parseFile((node) => {
+		if (node.type === "ClassDeclaration") {
+			for (const member of node.body.body) if ((member.type === "PropertyDefinition" || member.type === "MethodDefinition") && member.key.type === "Identifier" && member.key.name === "NotImplemented") notImplementedExceptionExists = true;
+		} else if (node.type === "VariableDeclaration") for (const decl of node.declarations) {
+			if (decl.init?.type !== "ObjectExpression") continue;
+			for (const prop of decl.init.properties) if (prop.type === "Property" && prop.key.type === "Identifier" && prop.key.name === "NotImplemented") notImplementedExceptionExists = true;
+		}
+	});
+	return notImplementedExceptionExists;
+}
+//#endregion
+//#region src/Modules/AddServiceModule.ts
+var AddServiceModule = class extends ModuleAbstract {
+	mainFileUpdater;
+	constructor(mainFileUpdater) {
+		super();
+		this.mainFileUpdater = mainFileUpdater;
+	}
+	keys = ["service", "svc"];
+	get help() {
+		return [
+			"Scaffold a standalone service with stubbed CRUD methods.",
+			"",
+			`Usage: ${EXE_NAME} ${this.keys.join("|")} ${NAME_FLAG_HELP}`,
+			"",
+			"Options:",
+			`  ${NAME_FLAG_HELP}   Name of the service to generate.`,
+			"  --empty             Generate a bare model with no default CRUD shape.",
+			"",
+			"Note: this only generates the service file. Without a matching model,",
+			"the stubbed methods will be untyped."
+		];
+	}
+	main() {
+		const name = this.flags.name;
+		assert(name, `name is required.\n\t${EXE_NAME} ${this.passedKey} ${NAME_FLAG_HELP}`);
+		const service = new Importable(name, "service");
+		const model = new Importable(name, "model");
+		const exception = new Importable(service.resourceName, "exception");
+		this.writeFile(this.buildServiceFile(service, model, exception), [service.filePath]);
+		this.mainFileUpdater.addLines("import", `import { ${service.pascalName} } from "${service.importFrom(this.config.main)}";`);
+		this.mainFileUpdater.addLines("service", `const ${service.camelName} = new ${service.pascalName}();`);
+	}
+	buildServiceFile(service, model, exception) {
+		if (fs.existsSync(model.filePath)) return this.buildServiceFileWithModel(service, model, exception);
+		if (this.flags.empty) return this.buildEmptyServiceFile(service);
+		return this.buildServiceFileWithDefaults(service, exception);
+	}
+	buildEmptyServiceFile(service) {
+		const b = new StringBuilder();
+		b.line(`export class ${service.pascalName} {`);
+		b.line(1)(`constructor() {}`);
+		b.line(`}`);
+		return b.toString();
+	}
+	buildServiceFileWithDefaults(service, exception) {
+		const b = new StringBuilder();
+		const methods = this.config.defaultMethods;
+		const notImplementedExceptionExists = checkNotImplementedExceptionExists(exception);
+		if (notImplementedExceptionExists) b.line(`import { ${exception.pascalName} } from "${exception.importFrom(service.filePath)}";`).line(``);
+		b.line(`export class ${service.pascalName} {`);
+		b.line(1)(`constructor() {}`);
+		for (const { propertyKey } of Object.values(methods)) {
+			b.line(``);
+			b.line(1)(`async ${propertyKey}(): Promise<void> {`);
+			if (notImplementedExceptionExists) b.line(2)(`throw ${exception.pascalName}.NotImplemented;`);
+			else b.line(2)(`throw new Error("Method not implemented.");`);
+			b.line(1)(`}`);
+		}
+		b.line(`}`);
+		return b.toString();
+	}
+	buildServiceFileWithModel(service, model, exception) {
+		const b = new StringBuilder();
+		const { modelTypeName, modelDef } = parseModelDefinition(model);
+		const notImplementedExceptionExists = checkNotImplementedExceptionExists(exception);
+		if (notImplementedExceptionExists) b.line(`import { ${exception.pascalName} } from "${exception.importFrom(service.filePath)}";`);
+		b.line(`import type { ${modelTypeName} } from "${model.importFrom(service.filePath)}";`);
+		b.line("");
+		b.line(`export class ${service.pascalName} {`);
+		b.line(1)(`constructor() {}`);
+		const isNeverSchema = (schema) => NEVER_SCHEMAS.has(schema.trim());
+		for (const [key, val] of Object.entries(modelDef)) {
+			const usedParams = [
+				"params",
+				"search",
+				"body"
+			].filter((k) => k in val && !isNeverSchema(val[k]));
+			const funcParams = usedParams.map((k) => `${k}: ${modelTypeName}["${key}"]["${k}"]`).join(", ");
+			const returnType = "response" in val && !isNeverSchema(val.response) ? `${modelTypeName}["${key}"]["response"]` : "void";
+			b.line(``);
+			b.line(1)(`async ${key}(${funcParams}): Promise<${returnType}> {`);
+			for (const param of usedParams) b.line(2)(`void ${param};`);
+			if (notImplementedExceptionExists) b.line(2)(`throw ${exception.pascalName}.NotImplemented;`);
+			else b.line(2)(`throw new Error("Method not implemented.");`);
+			b.line(1)(`}`);
+		}
+		b.line(`}`);
+		return b.toString();
+	}
+};
+//#endregion
+//#region src/internal/findEnclosingFunctionName.ts
+function findEnclosingFunctionName(source, matchIndex) {
+	let depth = 0;
+	let openIndex = -1;
+	for (let i = matchIndex; i >= 0; i--) {
+		const ch = source[i];
+		if (ch === "}") depth++;
+		else if (ch === "{") {
+			if (depth === 0) {
+				openIndex = i;
+				break;
+			}
+			depth--;
+		}
+	}
+	if (openIndex === -1) return null;
+	const before = source.slice(0, openIndex);
+	return (before.match(/(?:async\s+)?function\s*\*?\s*([A-Za-z0-9_$]+)\s*\([\s\S]*?\)\s*$/) ?? before.match(/(?:const|let|var)\s+([A-Za-z0-9_$]+)\s*=\s*(?:async\s*)?(?:function\s*)?\([\s\S]*?\)\s*(?:=>)?\s*$/))?.[1] ?? null;
+}
+//#endregion
+//#region src/Modules/ApiClientModule.ts
+var ApiClientModule = class extends ModuleAbstract {
+	keys = ["api"];
+	get help() {
+		return [
+			"Codegen for all routes",
+			"Generates types and model interfaces for all routes.",
+			"Generates an api client with methods for all routes. (unless disabled in config)",
+			"",
+			`Usage: ${EXE_NAME} ${this.keys.join("|")}`,
+			"",
+			"Note: Your entry file must call `.listen()` either at the top level",
+			"or inside a single function."
+		];
+	}
+	async main() {
+		const mainPath = path.resolve(this.config.main);
+		const outPath = mainPath.replace(/\.ts$/, ".temp.mjs");
+		const generatorImport = process.env.NODE_ENV === "development" ? "@/index" : process.env.NODE_ENV === "test" ? resolveCwdPath("dist") : "@ozanarslan/corpus-cli";
+		try {
+			const b = new StringBuilder();
+			b.line(`import { getNearestApp } from "${this.config.pkgPath}";`);
+			b.line(`import { ${GEN_FUNC} } from "${generatorImport}";`);
+			logger.step(`Reading main file at ${mainPath}`);
+			let mainFileContents = fs.readFileSync(mainPath, "utf-8");
+			const match = LISTEN_PATTERN.exec(mainFileContents);
+			if (!match) logFatal(`
+Could not find a .listen() call in: ${mainPath}.
+    Make sure your entry file calls .listen() either at the top level or inside a top level function.
+`.trim());
+			const funcName = findEnclosingFunctionName(mainFileContents, match.index);
+			if (funcName) {
+				logger.step(`Making sure ${funcName} is called.`);
+				const callSite = new RegExp(`^\\s*(?:void|await)?\\s*${funcName}\\s*\\(\\s*\\);?.*$`, "gm");
+				mainFileContents = mainFileContents.replace(callSite, "");
+				mainFileContents += `\n\nawait ${funcName}();\n`;
+			}
+			mainFileContents = mainFileContents.replace(LISTEN_PATTERN, `
+try {
+    const nearestApp = getNearestApp();
+    const config = ${JSON.stringify(this.config)};
+    ${GEN_FUNC}(nearestApp.prefix, nearestApp.routes, config);
+    process.exit(0);
+} catch (err) {
+    console.log(String(err));
+    process.exit(1);
+}
+`.trim());
+			b.line(mainFileContents);
+			logger.step(`Transpiling to JS...`);
+			const js = new Bun.Transpiler({ loader: "ts" }).transformSync(b.toString());
+			logger.step(`Writing temp file at ${outPath}`);
+			fs.writeFileSync(outPath, js, "utf-8");
+			logger.step(`Running generator...`);
+			const result = spawnSync(process.execPath, [outPath], {
+				stdio: "inherit",
+				env: process.env
+			});
+			if (result.status !== 0) logFatal(`exited with status ${result.status}`);
+			logger.success(`Generator completed successfully`);
+		} catch (err) {
+			logger.error(String(err));
+			process.exit(1);
+		} finally {
+			logger.step(`Deleting temp file at ${outPath}`);
+			fs.rmSync(outPath, { force: true });
+		}
+	}
+};
+//#endregion
+//#region src/cli.ts
+const mainFileUpdater = new MainFileUpdater();
+const apiClientModule = new ApiClientModule();
+const addServiceModule = new AddServiceModule(mainFileUpdater);
+const addControllerModule = new AddControllerModule(mainFileUpdater);
+const addModelModule = new AddModelModule();
+const addExceptionModule = new AddExceptionModule();
+const mods = [
+	apiClientModule,
+	addServiceModule,
+	addControllerModule,
+	addModelModule,
+	addExceptionModule,
+	new AddResourceModule(mainFileUpdater, addModelModule, addExceptionModule, addServiceModule, addControllerModule)
+];
+function printHelp() {
+	const pad = Math.max(...mods.map((m) => m.keys.join(", ").length)) + 2;
+	process.stdout.write([
+		`${EXE_NAME} — ${APP_NAME} Corpus codegen tool.`,
+		"",
+		"Usage:",
+		`  ${EXE_NAME} <module> [args]`,
+		"",
+		"modules:",
+		...mods.map((m) => `  ${m.keys.join(", ").padEnd(pad)}${m.help[0]}`),
+		"",
+		`Run \`${EXE_NAME} <module> --help\` for module-specific flags.`,
+		""
+	].join("\n"));
+}
+const first = process.argv.slice(2)[0];
+if (!first || first === "-h" || first === "--help") {
+	printHelp();
+	process.exit(first ? 0 : 1);
+}
+const mod = mods.find((m) => m.keys.includes(first));
+if (!mod) {
+	printHelp();
+	process.exit(1);
+}
+try {
+	await mod.run();
+} catch (err) {
+	await mod.stop();
+	logFatal(err);
+} finally {
+	await mod.stop();
+	process.exit(0);
+}
+//#endregion
+export {};