@workos/oagen 0.2.0 → 0.3.0

package/dist/cli/index.mjs

@@ -3,13 +3,14 @@ import "dotenv/config";
 import { Command } from "commander";
 import * as fs from "node:fs/promises";
 import { readFile } from "node:fs/promises";
-import * as path from "node:path";
-import { relative, resolve } from "node:path";
+import * as path$1 from "node:path";
+import path, { relative, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { BaseResolver, bundleDocument, createConfig, makeDocumentFromString } from "@redocly/openapi-core";
 import Parser from "tree-sitter";
+import { execFile, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { execFileSync } from "node:child_process";
 //#region src/errors.ts
 /**
 * Structured error hierarchy for oagen.
@@ -143,15 +144,49 @@ function walkTypeRef(ref, visitor) {
 //#endregion
 //#region src/utils/naming.ts
 /**
+* Known compound tokens that the regex-based splitter over-splits.
+* Each entry is [lowercase-word-sequence, canonical-form].
+* Sorted longest-first so greedy matching works correctly.
+*/
+const COMPOUND_WORDS = [[[
+	"m",
+	"2",
+	"m"
+], "M2M"], [["o", "auth"], "OAuth"]];
+/**
+* Recombine adjacent words that form a known compound token.
+*/
+function recombineCompounds(words) {
+	const result = [];
+	let i = 0;
+	while (i < words.length) {
+		let matched = false;
+		for (const [pattern, canonical] of COMPOUND_WORDS) if (i + pattern.length <= words.length) {
+			if (pattern.every((p, j) => words[i + j].toLowerCase() === p)) {
+				result.push(canonical);
+				i += pattern.length;
+				matched = true;
+				break;
+			}
+		}
+		if (!matched) {
+			result.push(words[i]);
+			i++;
+		}
+	}
+	return result;
+}
+/**
 * Split a string into words, handling:
 * - camelCase / PascalCase boundaries
 * - snake_case / kebab-case separators
 * - Consecutive capitals (e.g., "HTTPClient" → ["HTTP", "Client"])
 * - Numbers as word boundaries (e.g., "OAuth2Token" → ["OAuth", "2", "Token"])
+* - Known compounds are recombined (e.g., "M2M" stays as one word)
 */
 function splitWords(s) {
 	if (!s) return [];
-	return s.replace(/[^a-zA-Z0-9_\-\s.]/g, "_").replace(/([a-z])([A-Z])/g, "$1\0$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1\0$2").replace(/([a-zA-Z])(\d)/g, "$1\0$2").replace(/(\d)([a-zA-Z])/g, "$1\0$2").split(/[\0_\-\s.]+/).filter((w) => w.length > 0);
+	return recombineCompounds(s.replace(/[^a-zA-Z0-9_\-\s.]/g, "_").replace(/([a-z])([A-Z])/g, "$1\0$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1\0$2").replace(/([a-zA-Z])(\d)/g, "$1\0$2").replace(/(\d)([a-zA-Z])/g, "$1\0$2").split(/[\0_\-\s.]+/).filter((w) => w.length > 0));
 }
 const ACRONYM_SET = new Set([
 	"SSO",
@@ -159,7 +194,8 @@ const ACRONYM_SET = new Set([
 	"SAML",
 	"SCIM",
 	"JWT",
-	"HMAC"
+	"HMAC",
+	"M2M"
 ]);
 function toPascalCase(s, acronyms) {
 	const merged = acronyms ? new Set([...ACRONYM_SET, ...acronyms]) : ACRONYM_SET;
@@ -3310,11 +3346,27 @@ async function mergeIntoExisting(existingContent, generatedContent, language, he
 		const addedParts = [...toAppend];
 		if (insertions) for (const ins of insertions) addedParts.push(ins.text);
 		const addedCodeText = addedParts.join("\n");
-		const filteredImports = newImports.filter((imp) => {
+		const filteredImports = [];
+		for (const imp of newImports) {
 			const braceMatch = imp.text.match(/\{([^}]+)\}/);
-			if (!braceMatch) return true;
-			return braceMatch[1].split(",").map((n) => n.replace(/\btype\b/, "").trim()).filter(Boolean).some((name) => addedCodeText.includes(name));
-		});
+			if (!braceMatch) {
+				filteredImports.push(imp);
+				continue;
+			}
+			const names = braceMatch[1].split(",").map((n) => n.replace(/\btype\b/, "").trim()).filter(Boolean);
+			const usedNames = names.filter((name) => addedCodeText.includes(name));
+			if (usedNames.length === 0) continue;
+			if (usedNames.length === names.length) filteredImports.push(imp);
+			else {
+				const prefix = imp.text.trimStart().startsWith("import type") ? "import type" : "import";
+				const sourceMatch = imp.text.match(/from\s+(['"][^'"]+['"]);?/);
+				if (sourceMatch) filteredImports.push({
+					key: imp.key,
+					text: `${prefix} { ${usedNames.join(", ")} } from ${sourceMatch[1]};`
+				});
+				else filteredImports.push(imp);
+			}
+		}
 		if (filteredImports.length > 0) {
 			const renderedImports = adapter.renderImports ? adapter.renderImports(filteredImports) : filteredImports.map((entry) => entry.text);
 			const lines = result.split("\n");
@@ -3472,13 +3524,13 @@ async function writeFiles(files, outputDir, options) {
 	const language = options?.language;
 	const header = options?.header ?? "";
 	for (const file of sorted) {
-		const fullPath = path.join(outputDir, file.path);
+		const fullPath = path$1.join(outputDir, file.path);
 		let existingContent = null;
 		try {
 			existingContent = await fs.readFile(fullPath, "utf-8");
 		} catch {}
 		if (existingContent === null) {
-			await fs.mkdir(path.dirname(fullPath), { recursive: true });
+			await fs.mkdir(path$1.dirname(fullPath), { recursive: true });
 			await fs.writeFile(fullPath, file.content, "utf-8");
 			result.written.push(file.path);
 			continue;
@@ -3558,17 +3610,71 @@ function buildEmitterContext(spec, options) {
 		overlayLookup: options.overlayLookup
 	};
 }
+/**
+* Collect model and enum names transitively referenced by service operations.
+* Walks operation parameters, request bodies, responses, and pagination item
+* types, then chases model field references until the set stabilizes.
+*/
+function collectReferencedNames(services, models) {
+	const referencedModels = /* @__PURE__ */ new Set();
+	const referencedEnums = /* @__PURE__ */ new Set();
+	const collectFromTypeRef = (ref) => {
+		walkTypeRef(ref, {
+			model: (r) => referencedModels.add(r.name),
+			enum: (r) => referencedEnums.add(r.name)
+		});
+	};
+	for (const service of services) for (const op of service.operations) {
+		for (const p of [
+			...op.pathParams,
+			...op.queryParams,
+			...op.headerParams,
+			...op.cookieParams ?? []
+		]) collectFromTypeRef(p.type);
+		if (op.requestBody) collectFromTypeRef(op.requestBody);
+		collectFromTypeRef(op.response);
+		if (op.pagination) collectFromTypeRef(op.pagination.itemType);
+		for (const err of op.errors) if (err.type) collectFromTypeRef(err.type);
+		if (op.successResponses) for (const sr of op.successResponses) collectFromTypeRef(sr.type);
+	}
+	const modelsByName = new Map(models.map((m) => [m.name, m]));
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [...referencedModels];
+	while (queue.length > 0) {
+		const name = queue.pop();
+		if (visited.has(name)) continue;
+		visited.add(name);
+		const model = modelsByName.get(name);
+		if (!model) continue;
+		for (const field of model.fields) {
+			collectFromTypeRef(field.type);
+			for (const m of referencedModels) if (!visited.has(m)) queue.push(m);
+		}
+	}
+	return {
+		models: referencedModels,
+		enums: referencedEnums
+	};
+}
 /** Collect all generated files from an emitter (no headers, no path prefixes). */
 function generateAllFiles(spec, emitter, ctx) {
+	const referenced = collectReferencedNames(spec.services, spec.models);
+	const reachableModels = spec.models.filter((m) => referenced.models.has(m.name));
+	const reachableEnums = spec.enums.filter((e) => referenced.enums.has(e.name));
+	const reachableSpec = {
+		...spec,
+		models: reachableModels,
+		enums: reachableEnums
+	};
 	return [
-		...emitter.generateModels(spec.models, ctx),
-		...emitter.generateEnums(spec.enums, ctx),
+		...emitter.generateModels(reachableModels, ctx),
+		...emitter.generateEnums(reachableEnums, ctx),
 		...emitter.generateResources(spec.services, ctx),
 		...emitter.generateClient(spec, ctx),
 		...emitter.generateErrors(ctx),
 		...emitter.generateConfig(ctx),
-		...emitter.generateTypeSignatures?.(spec, ctx) ?? [],
-		...emitter.generateTests(spec, ctx),
+		...emitter.generateTypeSignatures?.(reachableSpec, ctx) ?? [],
+		...emitter.generateTests(reachableSpec, ctx),
 		...emitter.generateManifest?.(spec, ctx) ?? []
 	];
 }
@@ -3592,6 +3698,81 @@ function generateFiles(spec, emitter, options) {
 }
 //#endregion
 //#region src/engine/integrate.ts
+/**
+* Resolve a relative import path against a source file path to get the
+* target file path.  Handles implicit .ts extensions and /index.ts.
+*/
+function resolveImportPath(fromFilePath, importModulePath, knownPaths) {
+	const cleaned = importModulePath.replace(/^['"]|['"]$/g, "");
+	if (!cleaned.startsWith(".")) return void 0;
+	const dir = path.dirname(fromFilePath);
+	const resolved = path.normalize(path.join(dir, cleaned));
+	for (const candidate of [
+		resolved,
+		`${resolved}.ts`,
+		`${resolved}/index.ts`
+	]) if (knownPaths.has(candidate)) return candidate;
+}
+/**
+* Determine whether a generated file is a "root" — a file that should always
+* be integrated into the target.  Roots are entry points from which we trace
+* the import graph.  Everything else must be reachable from a root.
+*
+* Roots: resource classes, client, config, errors, enums, barrel index files.
+* Non-roots: serializers, fixtures, standalone interfaces, test files.
+*/
+function isRootFile(filePath) {
+	if (filePath.includes("/fixtures/")) return false;
+	if (filePath.endsWith(".spec.ts") || filePath.endsWith(".test.ts")) return false;
+	if (filePath.includes("/serializers/")) return false;
+	if (filePath.includes("/interfaces/") && !filePath.endsWith("/index.ts")) return false;
+	return true;
+}
+/**
+* Build a file-level dependency graph from generated files and return only
+* files reachable from root entry points.  Uses tree-sitter to parse imports.
+*/
+async function treeShakeFiles(files, language) {
+	if (!hasGrammar(language)) return files;
+	const knownPaths = new Set(files.map((f) => f.path));
+	const deps = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		if (!file.path.endsWith(".ts") && !file.path.endsWith(".js")) {
+			deps.set(file.path, /* @__PURE__ */ new Set());
+			continue;
+		}
+		const parsed = await extractStatements(file.content, language);
+		const fileDeps = /* @__PURE__ */ new Set();
+		for (const imp of parsed.imports) {
+			const resolved = resolveImportPath(file.path, imp.key, knownPaths);
+			if (resolved) fileDeps.add(resolved);
+		}
+		for (const stmt of parsed.statements) if (stmt.kind === "reexport") {
+			const match = stmt.text.match(/from\s+['"]([^'"]+)['"]/);
+			if (match) {
+				const resolved = resolveImportPath(file.path, match[1], knownPaths);
+				if (resolved) fileDeps.add(resolved);
+			}
+		}
+		deps.set(file.path, fileDeps);
+	}
+	const reachable = /* @__PURE__ */ new Set();
+	const queue = [];
+	for (const file of files) if (isRootFile(file.path)) {
+		reachable.add(file.path);
+		queue.push(file.path);
+	}
+	while (queue.length > 0) {
+		const current = queue.pop();
+		const fileDeps = deps.get(current);
+		if (!fileDeps) continue;
+		for (const dep of fileDeps) if (!reachable.has(dep)) {
+			reachable.add(dep);
+			queue.push(dep);
+		}
+	}
+	return files.filter((f) => reachable.has(f.path));
+}
 function mapFilesForTargetIntegration(files, language) {
 	const langPrefix = `${language}/`;
 	return files.filter((f) => f.integrateTarget !== false).map((f) => {
@@ -3604,12 +3785,44 @@ function mapFilesForTargetIntegration(files, language) {
 	});
 }
 async function integrateGeneratedFiles(opts) {
-	return writeFiles(mapFilesForTargetIntegration(opts.files, opts.language), opts.targetDir, {
+	return writeFiles(await treeShakeFiles(mapFilesForTargetIntegration(opts.files, opts.language), opts.language), opts.targetDir, {
 		language: opts.language,
 		header: opts.header
 	});
 }
 //#endregion
+//#region src/engine/formatter.ts
+/**
+* Post-integration formatter.
+*
+* After generating and merging files into a target directory, runs the
+* emitter-provided format command on all written/merged files so that
+* generated code matches the target project's style conventions.
+*/
+const execFileAsync = promisify(execFile);
+/**
+* Run the emitter's format command on the given target files.
+* Silently skips if the emitter has no formatCommand or returns null.
+*/
+async function formatTargetFiles(emitter, targetDir, filePaths) {
+	if (filePaths.length === 0) return;
+	if (!emitter.formatCommand) return;
+	const formatCmd = emitter.formatCommand(targetDir);
+	if (!formatCmd) return;
+	const absolutePaths = filePaths.map((f) => path$1.resolve(targetDir, f));
+	const batchSize = formatCmd.batchSize ?? 100;
+	for (let i = 0; i < absolutePaths.length; i += batchSize) {
+		const batch = absolutePaths.slice(i, i + batchSize);
+		try {
+			await execFileAsync(formatCmd.cmd, [...formatCmd.args, ...batch], {
+				cwd: targetDir,
+				maxBuffer: 10 * 1024 * 1024,
+				timeout: 12e4
+			});
+		} catch {}
+	}
+}
+//#endregion
 //#region src/engine/orchestrator.ts
 async function generate(spec, emitter, options) {
 	const { files: withHeaders, header } = generateFiles(spec, emitter, options);
@@ -3636,6 +3849,8 @@ async function generate(spec, emitter, options) {
 		if (targetResult.written.length > 0) console.log(`Target: created ${targetResult.written.length} new files`);
 		if (targetResult.merged.length > 0) console.log(`Target: merged into ${targetResult.merged.length} existing files (additive only)`);
 		if (targetResult.skipped.length > 0) console.log(`Target: skipped ${targetResult.skipped.length} files (excluded or no grammar)`);
+		const allTargetFiles = [...targetResult.written, ...targetResult.merged];
+		if (allTargetFiles.length > 0) await formatTargetFiles(emitter, options.target, allTargetFiles);
 	}
 	return withHeaders;
 }
@@ -4204,7 +4419,7 @@ function loadOverlayContext(opts) {
 		throw new ConfigError(`Failed to parse API surface JSON: ${err instanceof Error ? err.message : String(err)}`, `Ensure "${opts.apiSurfacePath}" contains valid JSON. Re-run \`oagen extract\` to regenerate it.`);
 	}
 	let manifest;
-	const resolvedManifestPath = opts.manifestPath ?? path.join(opts.outputDir, "smoke-manifest.json");
+	const resolvedManifestPath = opts.manifestPath ?? path$1.join(opts.outputDir, "smoke-manifest.json");
 	if (opts.manifestPath || existsSync(resolvedManifestPath)) try {
 		const parsed = JSON.parse(readFileSync(resolvedManifestPath, "utf-8"));
 		if (Array.isArray(parsed)) manifest = parsed;
@@ -5277,7 +5492,7 @@ function cleanGeneratedFiles(dir) {
 		return;
 	}
 	for (const entry of entries) {
-		const full = path.join(dir, entry);
+		const full = path$1.join(dir, entry);
 		let stat;
 		try {
 			stat = statSync(full);
@@ -5307,7 +5522,7 @@ function cleanGeneratedFiles(dir) {
 * it to ManifestEntry[] for the overlay builder.
 */
 function loadManifestFromDir(outputDir) {
-	const manifestPath = path.join(outputDir, "smoke-manifest.json");
+	const manifestPath = path$1.join(outputDir, "smoke-manifest.json");
 	if (!existsSync(manifestPath)) return void 0;
 	try {
 		const parsed = JSON.parse(readFileSync(manifestPath, "utf-8"));
@@ -5468,16 +5683,16 @@ function runStalenessCheck(baseline, oldSpec, newSpec, lang) {
 //#endregion
 //#region src/verify/run-smoke-check.ts
 const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+const __dirname = path$1.dirname(__filename);
 function resolveScript(scriptRelPath) {
-	const distScript = path.resolve(__dirname, "..", "..", "dist", "scripts", scriptRelPath.replace(/\.ts$/, ".js"));
+	const distScript = path$1.resolve(__dirname, "..", "..", "dist", "scripts", scriptRelPath.replace(/\.ts$/, ".js"));
 	if (existsSync(distScript)) return {
 		bin: "node",
 		script: distScript
 	};
 	return {
 		bin: "npx",
-		script: path.resolve(__dirname, "..", "..", "scripts", scriptRelPath)
+		script: path$1.resolve(__dirname, "..", "..", "scripts", scriptRelPath)
 	};
 }
 function runPackagedScript(scriptRelPath, args) {
@@ -5928,7 +6143,7 @@ const CONFIG_NAMES = [
 ];
 async function loadConfig(cwd = process.cwd()) {
 	for (const name of CONFIG_NAMES) {
-		const configPath = path.resolve(cwd, name);
+		const configPath = path$1.resolve(cwd, name);
 		if (!existsSync(configPath)) continue;
 		try {
 			const mod = await import(pathToFileURL(configPath).href);