@rexeus/typeweaver 0.8.0 → 0.9.0

package/dist/cli-B-KPX-Jc.mjs

@@ -0,0 +1,407 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { Command } from "commander";
+import { createPluginContextBuilder, createPluginRegistry, normalizeSpec } from "@rexeus/typeweaver-gen";
+import TypesPlugin from "@rexeus/typeweaver-types";
+import ejs from "ejs";
+import os from "node:os";
+import { Rolldown } from "tsdown";
+import { HttpMethod, HttpStatusCode } from "@rexeus/typeweaver-core";
+//#region src/generators/formatter.ts
+async function formatCode(outputDir, startDir) {
+	const format = await loadFormatter();
+	if (!format) return;
+	await formatDirectory(startDir ?? outputDir, format);
+}
+async function loadFormatter() {
+	try {
+		return (await import("oxfmt")).format;
+	} catch {
+		console.warn("oxfmt not installed - skipping formatting. Install with: npm install -D oxfmt");
+		return;
+	}
+}
+async function formatDirectory(targetDir, format) {
+	const contents = fs.readdirSync(targetDir, { withFileTypes: true });
+	for (const content of contents) if (content.isFile()) {
+		const filePath = path.join(targetDir, content.name);
+		const { code } = await format(filePath, fs.readFileSync(filePath, "utf8"));
+		fs.writeFileSync(filePath, code);
+	} else if (content.isDirectory()) await formatDirectory(path.join(targetDir, content.name), format);
+}
+//#endregion
+//#region src/generators/indexFileGenerator.ts
+function generateIndexFiles(templateDir, context) {
+	const templateFilePath = path.join(templateDir, "Index.ejs");
+	const template = fs.readFileSync(templateFilePath, "utf8");
+	const generatedFiles = context.getGeneratedFiles();
+	const groups = /* @__PURE__ */ new Map();
+	const rootFiles = /* @__PURE__ */ new Set();
+	const existingBarrels = /* @__PURE__ */ new Set();
+	for (const file of generatedFiles) {
+		const stripped = file.replace(/\.ts$/, "");
+		const firstSlash = stripped.indexOf("/");
+		if (firstSlash === -1) {
+			rootFiles.add(`./${stripped}`);
+			continue;
+		}
+		const firstSegment = stripped.slice(0, firstSlash);
+		if (firstSegment === "lib") {
+			const secondSlash = stripped.indexOf("/", firstSlash + 1);
+			const groupKey = secondSlash === -1 ? stripped : stripped.slice(0, secondSlash);
+			const entryName = stripped.slice(groupKey.length + 1);
+			if (entryName === "index") existingBarrels.add(groupKey);
+			else {
+				if (!groups.has(groupKey)) groups.set(groupKey, /* @__PURE__ */ new Set());
+				groups.get(groupKey).add(`./${entryName}`);
+			}
+		} else {
+			const entryName = stripped.slice(firstSlash + 1);
+			if (entryName === "index") existingBarrels.add(firstSegment);
+			else {
+				if (!groups.has(firstSegment)) groups.set(firstSegment, /* @__PURE__ */ new Set());
+				groups.get(firstSegment).add(`./${entryName}`);
+			}
+		}
+	}
+	for (const [groupKey, entries] of groups) {
+		if (existingBarrels.has(groupKey)) continue;
+		const domainBarrelContent = ejs.render(template, { indexPaths: Array.from(entries).sort() });
+		const domainIndexPath = path.join(context.outputDir, groupKey, "index.ts");
+		fs.mkdirSync(path.dirname(domainIndexPath), { recursive: true });
+		fs.writeFileSync(domainIndexPath, domainBarrelContent);
+	}
+	const rootIndexPaths = new Set(rootFiles);
+	for (const groupKey of groups.keys()) rootIndexPaths.add(`./${groupKey}`);
+	for (const barrelKey of existingBarrels) rootIndexPaths.add(`./${barrelKey}`);
+	const rootContent = ejs.render(template, { indexPaths: Array.from(rootIndexPaths).sort() });
+	fs.writeFileSync(path.join(context.outputDir, "index.ts"), rootContent);
+}
+//#endregion
+//#region src/generators/errors/PluginLoadingFailure.ts
+var PluginLoadingFailure = class PluginLoadingFailure extends Error {
+	constructor(pluginName, attempts) {
+		super(`Failed to load plugin '${pluginName}'`);
+		this.pluginName = pluginName;
+		this.attempts = attempts;
+		Object.setPrototypeOf(this, PluginLoadingFailure.prototype);
+	}
+};
+//#endregion
+//#region src/generators/pluginLoader.ts
+async function loadPlugins(registry, requiredPlugins, strategies, config) {
+	for (const requiredPlugin of requiredPlugins) registry.register(requiredPlugin);
+	if (!config?.plugins) return;
+	const successful = [];
+	for (const plugin of config.plugins) {
+		let result;
+		if (typeof plugin === "string") result = await loadPlugin(plugin, strategies);
+		else result = await loadPlugin(plugin[0], strategies);
+		if (result.success === false) throw new PluginLoadingFailure(result.error.pluginName, result.error.attempts);
+		successful.push(result.value);
+		registry.register(result.value.plugin);
+	}
+	reportSuccessfulLoads(successful);
+}
+async function loadPlugin(pluginName, strategies) {
+	const possiblePaths = generatePluginPaths(pluginName, strategies);
+	const attempts = [];
+	for (const possiblePath of possiblePaths) try {
+		const pluginPackage = await import(possiblePath);
+		if (pluginPackage.default) return {
+			success: true,
+			value: {
+				plugin: new pluginPackage.default(),
+				source: possiblePath
+			}
+		};
+		attempts.push({
+			path: possiblePath,
+			error: "No default export found"
+		});
+	} catch (error) {
+		attempts.push({
+			path: possiblePath,
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+	return {
+		success: false,
+		error: {
+			pluginName,
+			attempts
+		}
+	};
+}
+function generatePluginPaths(pluginName, strategies) {
+	const paths = [];
+	for (const strategy of strategies) switch (strategy) {
+		case "npm":
+			paths.push(`@rexeus/typeweaver-${pluginName}`);
+			paths.push(`@rexeus/${pluginName}`);
+			break;
+		case "local":
+			paths.push(pluginName);
+			break;
+	}
+	return paths;
+}
+function reportSuccessfulLoads(successful) {
+	if (successful.length > 0) {
+		console.info(`Successfully loaded ${successful.length} plugin(s):`);
+		for (const result of successful) console.info(`  - ${result.plugin.name} (from ${result.source})`);
+	}
+}
+//#endregion
+//#region src/generators/spec/specBundler.ts
+const WINDOWS_ABSOLUTE_PATH_PATTERN = /^[A-Za-z]:[\\/]/;
+const WINDOWS_UNC_PATH_PATTERN = /^\\\\/;
+function createWrapperImportSpecifier(wrapperFile, inputFile) {
+	const absoluteInputFile = resolveBundledInputFile(inputFile);
+	const useWindowsPathSemantics = usesWindowsPathSemantics(wrapperFile, absoluteInputFile);
+	const pathModule = useWindowsPathSemantics ? path.win32 : path.posix;
+	const wrapperDir = useWindowsPathSemantics ? pathModule.dirname(wrapperFile) : resolveRealFilePath(pathModule.dirname(wrapperFile));
+	const resolvedInputFile = useWindowsPathSemantics ? absoluteInputFile : resolveRealFilePath(absoluteInputFile);
+	const relativeInputFile = pathModule.relative(wrapperDir, resolvedInputFile).replaceAll(pathModule.sep, "/");
+	if (relativeInputFile.startsWith(".") || relativeInputFile.startsWith("..")) return relativeInputFile;
+	return `./${relativeInputFile}`;
+}
+async function bundle(config) {
+	const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "typeweaver-spec-loader-"));
+	const wrapperFile = path.join(tempDir, "spec-entrypoint.ts");
+	const bundledSpecFile = path.join(config.specOutputDir, "spec.js");
+	const wrapperImportSpecifier = createWrapperImportSpecifier(wrapperFile, config.inputFile);
+	fs.writeFileSync(wrapperFile, [
+		`import * as specModule from ${JSON.stringify(wrapperImportSpecifier)};`,
+		"const resolvedSpec =",
+		"  Reflect.get(specModule, \"default\") ??",
+		"  Reflect.get(specModule, \"spec\") ??",
+		"  specModule;",
+		"",
+		"export default resolvedSpec;",
+		"export const spec = resolvedSpec;",
+		""
+	].join("\n"));
+	try {
+		await Rolldown.build({
+			cwd: tempDir,
+			input: wrapperFile,
+			treeshake: true,
+			external: (source) => {
+				if (source.startsWith("node:")) return true;
+				return !source.startsWith(".") && !path.isAbsolute(source);
+			},
+			output: {
+				file: bundledSpecFile,
+				format: "esm"
+			}
+		});
+	} finally {
+		fs.rmSync(tempDir, {
+			recursive: true,
+			force: true
+		});
+	}
+	if (!fs.existsSync(bundledSpecFile)) throw new Error(`Failed to bundle spec entrypoint '${config.inputFile}' to '${bundledSpecFile}'.`);
+	return bundledSpecFile;
+}
+function resolveBundledInputFile(inputFile) {
+	if (path.isAbsolute(inputFile)) return inputFile;
+	if (WINDOWS_ABSOLUTE_PATH_PATTERN.test(inputFile)) return path.win32.normalize(inputFile);
+	if (WINDOWS_UNC_PATH_PATTERN.test(inputFile)) return path.win32.normalize(inputFile);
+	return path.resolve(inputFile);
+}
+function usesWindowsPathSemantics(...filePaths) {
+	return filePaths.some((filePath) => {
+		return WINDOWS_ABSOLUTE_PATH_PATTERN.test(filePath) || WINDOWS_UNC_PATH_PATTERN.test(filePath);
+	});
+}
+function resolveRealFilePath(filePath) {
+	if (!fs.existsSync(filePath)) return filePath;
+	return fs.realpathSync.native(filePath);
+}
+//#endregion
+//#region src/generators/spec/InvalidSpecEntrypointError.ts
+var InvalidSpecEntrypointError = class extends Error {
+	constructor(specEntrypoint) {
+		super(`Spec entrypoint '${specEntrypoint}' must export a SpecDefinition as its default export, named 'spec' export, or module namespace.`);
+		this.name = "InvalidSpecEntrypointError";
+	}
+};
+//#endregion
+//#region src/generators/spec/specGuards.ts
+const validHttpStatusCodes = new Set(Object.values(HttpStatusCode).filter((statusCode) => typeof statusCode === "number"));
+const isRecord = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const isResponseDefinition = (value) => {
+	if (!isRecord(value)) return false;
+	return typeof value.name === "string" && value.name.length > 0 && typeof value.description === "string" && value.description.length > 0 && validHttpStatusCodes.has(value.statusCode);
+};
+const isOperationDefinition = (value) => {
+	if (!isRecord(value) || !Array.isArray(value.responses)) return false;
+	return typeof value.operationId === "string" && value.operationId.length > 0 && typeof value.path === "string" && value.path.length > 0 && typeof value.summary === "string" && value.summary.length > 0 && Object.values(HttpMethod).includes(value.method) && isRecord(value.request) && value.responses.length > 0 && value.responses.every((response) => isResponseDefinition(response));
+};
+const isResourceDefinition = (value) => {
+	return isRecord(value) && Array.isArray(value.operations) && value.operations.every(isOperationDefinition);
+};
+const isSpecDefinition = (value) => {
+	if (!isRecord(value) || !isRecord(value.resources)) return false;
+	return Object.values(value.resources).every(isResourceDefinition);
+};
+//#endregion
+//#region src/generators/spec/specImporter.ts
+async function importDefinition(bundledSpecFile) {
+	const specModule = await import(pathToFileURL(bundledSpecFile).toString());
+	const definition = specModule.default ?? specModule.spec ?? specModule;
+	if (!isSpecDefinition(definition)) throw new InvalidSpecEntrypointError(bundledSpecFile);
+	return definition;
+}
+//#endregion
+//#region src/generators/specLoader.ts
+async function loadSpec(config) {
+	fs.mkdirSync(config.specOutputDir, { recursive: true });
+	const bundledSpecFile = await bundle(config);
+	writeSpecDeclarationFile(config.specOutputDir);
+	const definition = await importDefinition(bundledSpecFile);
+	return {
+		definition,
+		normalizedSpec: normalizeSpec(definition)
+	};
+}
+function writeSpecDeclarationFile(specOutputDir) {
+	fs.writeFileSync(`${specOutputDir}/spec.d.ts`, [
+		"import type { SpecDefinition } from \"@rexeus/typeweaver-core\";",
+		"declare const _default: SpecDefinition;",
+		"export default _default;",
+		"export declare const spec: SpecDefinition;",
+		""
+	].join("\n"));
+}
+//#endregion
+//#region src/generators/Generator.ts
+const moduleDir$1 = path.dirname(fileURLToPath(import.meta.url));
+/**
+* Main generator for typeweaver
+* Uses a plugin-based architecture for extensible code generation
+*/
+var Generator = class {
+	coreDir = "@rexeus/typeweaver-core";
+	templateDir = path.join(moduleDir$1, "templates");
+	registry = createPluginRegistry();
+	contextBuilder = createPluginContextBuilder();
+	requiredPlugins;
+	strategies;
+	inputFile = "";
+	outputDir = "";
+	specOutputDir = "";
+	responsesOutputDir = "";
+	constructor(requiredPlugins = [new TypesPlugin()], strategies) {
+		this.requiredPlugins = requiredPlugins;
+		this.strategies = strategies ?? ["npm", "local"];
+	}
+	/**
+	* Generate code using the plugin system
+	*/
+	async generate(specFile, outputDir, config) {
+		console.info("Starting generation...");
+		this.initializeDirectories(specFile, outputDir);
+		if (config?.clean ?? true) {
+			console.info("Cleaning output directory...");
+			fs.rmSync(this.outputDir, {
+				recursive: true,
+				force: true
+			});
+		}
+		fs.mkdirSync(this.outputDir, { recursive: true });
+		fs.mkdirSync(this.responsesOutputDir, { recursive: true });
+		fs.mkdirSync(this.specOutputDir, { recursive: true });
+		await loadPlugins(this.registry, this.requiredPlugins, this.strategies, config);
+		console.info(`Bundling spec from '${this.inputFile}' to '${this.specOutputDir}'...`);
+		let { normalizedSpec } = await loadSpec({
+			inputFile: this.inputFile,
+			specOutputDir: this.specOutputDir
+		});
+		const pluginContext = this.contextBuilder.createPluginContext({
+			outputDir: this.outputDir,
+			inputDir: path.dirname(this.inputFile),
+			config: config ?? {}
+		});
+		console.info("Initializing plugins...");
+		for (const registration of this.registry.getAll()) if (registration.plugin.initialize) await registration.plugin.initialize(pluginContext);
+		console.info("Collecting resources...");
+		for (const registration of this.registry.getAll()) if (registration.plugin.collectResources) normalizedSpec = await registration.plugin.collectResources(normalizedSpec);
+		const generatorContext = this.contextBuilder.createGeneratorContext({
+			outputDir: this.outputDir,
+			inputDir: path.dirname(this.inputFile),
+			config: config ?? {},
+			normalizedSpec,
+			templateDir: this.templateDir,
+			coreDir: this.coreDir,
+			responsesOutputDir: this.responsesOutputDir,
+			specOutputDir: this.specOutputDir
+		});
+		console.info("Generating code...");
+		for (const registration of this.registry.getAll()) {
+			console.info(`Running plugin: ${registration.plugin.name}`);
+			if (registration.plugin.generate) await registration.plugin.generate(generatorContext);
+		}
+		generateIndexFiles(this.templateDir, generatorContext);
+		console.info("Finalizing plugins...");
+		for (const registration of this.registry.getAll()) if (registration.plugin.finalize) await registration.plugin.finalize(pluginContext);
+		if (config?.format ?? true) await formatCode(this.outputDir);
+		console.info("Generation complete!");
+		console.info(`Generated files: ${this.contextBuilder.getGeneratedFiles().length}`);
+	}
+	initializeDirectories(specFile, outputDir) {
+		this.inputFile = specFile;
+		this.outputDir = outputDir;
+		this.responsesOutputDir = path.join(outputDir, "responses");
+		this.specOutputDir = path.join(this.outputDir, "spec");
+	}
+};
+//#endregion
+//#region src/cli.ts
+const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+const packageJson = JSON.parse(fs.readFileSync(path.join(moduleDir, "../package.json"), "utf-8"));
+const program = new Command();
+const execDir = process.cwd();
+program.name("@rexeus/typeweaver").description("Type-safe API framework with code generation for TypeScript").version(packageJson.version);
+program.command("generate").description("Generate types, validators, and clients from an API spec").option("-i, --input <inputPath>", "path to spec entrypoint file").option("-o, --output <outputDir>", "output directory for generated files").option("-c, --config <configFile>", "path to configuration file").option("-p, --plugins <plugins>", "comma-separated list of plugins to use").option("--format", "format generated code with oxfmt (default: true)").option("--no-format", "disable code formatting").option("--clean", "clean output directory before generation (default: true)").option("--no-clean", "disable cleaning output directory").action(async (options) => {
+	let config = {};
+	if (options.config) {
+		const configPath = path.isAbsolute(options.config) ? options.config : path.join(execDir, options.config);
+		try {
+			const configModule = await import(pathToFileURL(configPath).toString());
+			config = configModule.default ?? configModule;
+			console.info(`Loaded configuration from ${configPath}`);
+		} catch (error) {
+			console.error(`Failed to load configuration file: ${options.config}`);
+			console.error(error);
+			process.exit(1);
+		}
+	}
+	const inputPath = options.input ?? config.input;
+	const outputDir = options.output ?? config.output;
+	if (!inputPath) throw new Error("No input spec entrypoint provided. Use --input or specify in config file.");
+	if (!outputDir) throw new Error("No output directory provided. Use --output or specify in config file.");
+	const resolvedInputPath = path.isAbsolute(inputPath) ? inputPath : path.join(execDir, inputPath);
+	const resolvedOutputDir = path.isAbsolute(outputDir) ? outputDir : path.join(execDir, outputDir);
+	const finalConfig = {
+		input: resolvedInputPath,
+		output: resolvedOutputDir,
+		format: options.format ?? config.format ?? true,
+		clean: options.clean ?? config.clean ?? true
+	};
+	if (options.plugins) finalConfig.plugins = options.plugins.split(",").map((p) => p.trim());
+	else if (config.plugins) finalConfig.plugins = config.plugins;
+	return new Generator().generate(resolvedInputPath, resolvedOutputDir, finalConfig);
+});
+program.command("init").description("Initialize a new typeweaver project (coming soon)").action(() => {
+	console.log("The init command is coming soon!");
+});
+program.parse(process.argv);
+//#endregion
+export {};