@workos/oagen 0.2.0 → 0.3.0

package/dist/compat/index.mjs

@@ -1,5 +1,5 @@
-import { t as safeParse$1, v as ExtractorError } from "../tree-sitter-BPNfbEzY.mjs";
-import { _ as registerExtractor, a as specDerivedHttpKeys, c as buildOverlayLookup, d as defaultIsNullableOnlyDifference, f as namedTypeWordsOverlap, g as getExtractor, h as typeExistsInSurface, i as specDerivedFieldPaths, l as patchOverlay, m as resolveHints, n as filterSurface, o as specDerivedMethodPaths, p as nodeHints, r as specDerivedEnumValues, s as specDerivedNames, t as diffSurfaces, u as NAMED_TYPE_RE } from "../differ-BwelBJN0.mjs";
+import { t as safeParse$1, v as ExtractorError } from "../tree-sitter-DFRXfWg9.mjs";
+import { _ as registerExtractor, a as specDerivedHttpKeys, c as buildOverlayLookup, d as defaultIsNullableOnlyDifference, f as namedTypeWordsOverlap, g as getExtractor, h as typeExistsInSurface, i as specDerivedFieldPaths, l as patchOverlay, m as resolveHints, n as filterSurface, o as specDerivedMethodPaths, p as nodeHints, r as specDerivedEnumValues, s as specDerivedNames, t as diffSurfaces, u as NAMED_TYPE_RE } from "../differ-B6472Yef.mjs";
 import path, { basename, dirname, join, relative, resolve } from "node:path";
 import Parser from "tree-sitter";
 import ts from "typescript";

package/dist/{diff-DyQF4sel.mjs → diff-Cn6S74vV.mjs}

@@ -1,7 +1,10 @@
-import { C as assertNever, f as toSnakeCase, i as normalizeJsExtension, t as safeParse, x as RegistryError } from "./tree-sitter-BPNfbEzY.mjs";
+import { A as walkTypeRef, C as assertNever, f as toSnakeCase, i as normalizeJsExtension, t as safeParse, x as RegistryError } from "./tree-sitter-DFRXfWg9.mjs";
 import * as fs from "node:fs/promises";
 import * as path$1 from "node:path";
+import path from "node:path";
 import Parser from "tree-sitter";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 //#region src/engine/merge-adapters/url-fingerprint.ts
 /**
 * Extract a URL path fingerprint from a method body using tree-sitter AST traversal.
@@ -1558,11 +1561,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");
@@ -1806,17 +1825,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) ?? []
 	];
 }
@@ -1840,6 +1913,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) => {
@@ -1852,12 +2000,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);
@@ -1884,6 +2064,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;
 }
@@ -2245,6 +2427,6 @@ function summarize(changes) {
 	};
 }
 //#endregion
-export { integrateGeneratedFiles as a, buildEmitterContext as c, generate as i, generateAllFiles as l, getEmitter as n, mapFilesForTargetIntegration as o, registerEmitter as r, applyFileHeaders as s, diffSpecs as t, generateFiles as u };
+export { integrateGeneratedFiles as a, applyFileHeaders as c, generateAllFiles as d, generateFiles as f, generate as i, buildEmitterContext as l, getEmitter as n, mapFilesForTargetIntegration as o, registerEmitter as r, treeShakeFiles as s, diffSpecs as t, collectReferencedNames as u };
 
-//# sourceMappingURL=diff-DyQF4sel.mjs.map
+//# sourceMappingURL=diff-Cn6S74vV.mjs.map