@workos/oagen 0.21.0 → 0.21.1

package/dist/cli/index.mjs

@@ -433,7 +433,7 @@ function qualifyInlineModelName(baseName, parentName) {
 function extractInlineModelsFromSchemas(schemas) {
 	if (!schemas) return [];
 	const inlineModels = [];
-	for (const [schemaName, schema] of Object.entries(schemas)) extractInlineModelsFromProperties(schema, inlineModels, cleanSchemaName(toPascalCase(schemaName)));
+	for (const [schemaName, schema] of Object.entries(schemas)) extractInlineModelsFromProperties(schema, inlineModels, resolveSchemaName(schemaName));
 	return inlineModels;
 }
 function extractInlineModelsFromProperties(schema, results, parentName) {
@@ -2617,6 +2617,27 @@ function collapseJsonSuffixModels(models, services) {
 		rewriteModelRefs(normalizedModels, services, jsonModel.name, baseModel.name);
 		console.warn(`[oagen] Merged "${jsonModel.name}" into "${baseModel.name}" (${jsonModel.fields.length} fields, superset)`);
 	}
+	for (const { jsonModel, baseModel } of mergeCandidates) {
+		const jsonPrefix = jsonModel.name;
+		const basePrefix = baseModel.name;
+		for (const model of normalizedModels) {
+			if (toRemove.has(model.name)) continue;
+			if (model.name.length <= jsonPrefix.length) continue;
+			if (!model.name.startsWith(jsonPrefix)) continue;
+			const newName = basePrefix + model.name.slice(jsonPrefix.length);
+			const existing = byName.get(newName);
+			if (existing && !toRemove.has(existing.name)) {
+				toRemove.add(model.name);
+				rewriteModelRefs(normalizedModels, services, model.name, newName);
+				console.warn(`[oagen] Collapsed child "${model.name}" into existing "${newName}"`);
+			} else {
+				rewriteModelRefs(normalizedModels, services, model.name, newName);
+				model.name = newName;
+				byName.set(newName, model);
+				console.warn(`[oagen] Renamed child "${jsonPrefix}…" → "${newName}"`);
+			}
+		}
+	}
 	return normalizedModels.filter((m) => !toRemove.has(m.name));
 }
 //#endregion
@@ -2669,8 +2690,10 @@ async function parseSpec(specPath, options) {
 	if (!version.startsWith("3.")) throw new SpecParseError(`Unsupported OpenAPI version: ${version}. oagen requires OpenAPI 3.x`, `Update the spec to OpenAPI 3.0 or 3.1. If you are using Swagger 2.x, convert it first with \`npx swagger2openapi ${specPath}\`.`);
 	const { models, enums } = extractSchemas(spec.components?.schemas, { schemaNameTransform: options?.schemaNameTransform });
 	const { services, inlineModels } = extractOperations(spec.paths, options?.operationIdTransform, spec.components?.schemas);
+	const responseNormalizedModels = mergeInlineResponseModels(models, inlineModels);
+	const fieldInlineModels = extractInlineModelsFromSchemas(spec.components?.schemas);
 	clearSchemaNameTransform();
-	const finalModels = collapseJsonSuffixModels(mergeFieldInlineModels(mergeInlineResponseModels(models, inlineModels), extractInlineModelsFromSchemas(spec.components?.schemas)), services);
+	const finalModels = collapseJsonSuffixModels(mergeFieldInlineModels(responseNormalizedModels, fieldInlineModels), services);
 	collectInlineEnumsFromModels(finalModels, enums);
 	collectInlineEnumsFromOperations(services, enums);
 	const auth = extractAuthSchemes(spec.components?.securitySchemes);
@@ -4279,10 +4302,10 @@ async function extractClassEndLines(source, language) {
 	const tree = safeParse(await getParser(language), source);
 	const map = /* @__PURE__ */ new Map();
 	function processClassNode(node) {
-		const nameNode = node.childForFieldName("name");
+		const nameNode = node.childForFieldName("name") ?? node.children.find((c) => c.type === "type_identifier" || c.type === "identifier");
 		if (!nameNode) return;
 		const name = nameNode.text;
-		const body = node.childForFieldName("body");
+		const body = node.childForFieldName("body") ?? node.children.find((c) => c.type === "class_body" || c.type === "body");
 		const endRow = body ? body.endPosition.row : node.endPosition.row;
 		if (source[body ? body.endIndex - 1 : node.endIndex - 1] === "}") map.set(name, { bodyEndLine: endRow });
 		else map.set(name, { bodyEndLine: endRow + 1 });
@@ -4831,9 +4854,16 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 		if (!existingLines[i].includes("@oagen-ignore-start")) continue;
 		const startIdx = i;
 		while (i < existingLines.length && !existingLines[i].includes("@oagen-ignore-end")) i++;
+		let anchor = "";
+		for (let a = i + 1; a < existingLines.length; a++) if (existingLines[a].trim()) {
+			anchor = existingLines[a].trimStart();
+			break;
+		}
 		blocks.push({
 			containingClass: findContainingClass(existingLines, startIdx),
-			lines: existingLines.slice(startIdx, i + 1)
+			containingScope: findContainingDescribeScope(existingLines, startIdx),
+			lines: existingLines.slice(startIdx, i + 1),
+			anchor
 		});
 	}
 	if (blocks.length === 0) return generatedContent;
@@ -4843,15 +4873,19 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 	const blocksByClass = /* @__PURE__ */ new Map();
 	for (const b of blocks) {
 		if (!blocksByClass.has(b.containingClass)) blocksByClass.set(b.containingClass, []);
-		blocksByClass.get(b.containingClass).push(b.lines);
+		blocksByClass.get(b.containingClass).push({
+			containingScope: b.containingScope,
+			lines: b.lines,
+			anchor: b.anchor
+		});
 	}
 	const replacedClasses = /* @__PURE__ */ new Set();
 	const handledBlockKeys = /* @__PURE__ */ new Set();
 	const replacements = [];
 	for (const [className, classBlocks] of blocksByClass) {
 		let targetClass = className;
-		if (!targetClass) for (const blockLines of classBlocks) {
-			for (const l of blockLines) {
+		if (!targetClass) for (const entry of classBlocks) {
+			for (const l of entry.lines) {
 				const m = l.match(/^(?:export\s+)?class\s+(\w+)/);
 				if (m && classEndLines.has(m[1])) {
 					targetClass = m[1];
@@ -4861,7 +4895,7 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 			if (targetClass) break;
 		}
 		if (!targetClass) continue;
-		if (!classBlocks.some((blockLines) => blockLines.some((l) => {
+		if (!classBlocks.some((entry) => entry.lines.some((l) => {
 			return l.match(/^(?:export\s+)?class\s+(\w+)/)?.[1] === targetClass;
 		}))) continue;
 		const info = classEndLines.get(targetClass);
@@ -4869,9 +4903,9 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 		const startLine = findClassDeclarationStart(result, targetClass, info.bodyEndLine);
 		if (startLine < 0) continue;
 		const content = [];
-		for (const block of classBlocks) {
+		for (const entry of classBlocks) {
 			content.push("");
-			content.push(...block);
+			content.push(...entry.lines);
 		}
 		replacements.push({
 			startLine,
@@ -4886,22 +4920,46 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 	let effectiveClassEndLines = classEndLines;
 	if (replacedClasses.size > 0) effectiveClassEndLines = await extractClassEndLines(result.join("\n"), language);
 	const insertions = [];
+	let insertionOrder = 0;
 	for (const [className, classBlocks] of blocksByClass) {
 		if (handledBlockKeys.has(className) || replacedClasses.has(className)) continue;
 		const info = className ? effectiveClassEndLines.get(className) : void 0;
-		const insertLine = info ? info.bodyEndLine : result.length;
-		const content = [];
-		for (const block of classBlocks) {
-			content.push("");
-			content.push(...block);
+		for (const entry of classBlocks) {
+			let insertLine;
+			if (entry.anchor && !entry.anchor.includes("@oagen-ignore") && /[a-zA-Z]|^\/\*|^\/\//.test(entry.anchor)) {
+				for (let li = 0; li < result.length; li++) if (result[li].trimStart() === entry.anchor) {
+					insertLine = li;
+					break;
+				}
+			}
+			if (insertLine === void 0) if (info) insertLine = info.bodyEndLine;
+			else {
+				const scopeEndLine = entry.containingScope ? findDescribeScopeEndLine(result, entry.containingScope) : void 0;
+				const blockHasImportsFallback = entry.lines.some((l) => /^\s*(import|from)\s/.test(l));
+				if (scopeEndLine !== void 0) insertLine = scopeEndLine;
+				else if (blockHasImportsFallback || hasTopLevelDeclaration(entry.lines)) {
+					let lastImportLine = 0;
+					for (let li = 0; li < result.length; li++) {
+						const trimmed = result[li].trimStart();
+						if (/^(import|from)\s/.test(trimmed)) lastImportLine = li + 1;
+					}
+					insertLine = lastImportLine;
+				} else insertLine = result.length;
+			}
+			if (entry.lines.some((l) => /^\s*import\s/.test(l))) while (insertLine >= 2 && result[insertLine - 1]?.trim() === "" && /^\s*(import|using|from)\s/.test(result[insertLine - 2] ?? "")) insertLine--;
+			const prevLine = insertLine > 0 ? result[insertLine - 1]?.trimStart() ?? "" : "";
+			const blockContent = /^import\s/.test(prevLine) || /^using\s/.test(prevLine) || /^from\s/.test(prevLine) || insertLine > 0 && prevLine === "" ? [...entry.lines] : ["", ...entry.lines];
+			if ((result[insertLine]?.trimStart() ?? "").startsWith("///")) blockContent.push("");
+			insertions.push({
+				line: insertLine,
+				order: insertionOrder++,
+				content: blockContent
+			});
 		}
-		insertions.push({
-			line: insertLine,
-			content
-		});
 	}
-	insertions.sort((a, b) => b.line - a.line);
+	insertions.sort((a, b) => b.line - a.line || b.order - a.order);
 	for (const ins of insertions) result.splice(ins.line, 0, ...ins.content);
+	removeDuplicateImportsCoveredByIgnoreBlocks(result);
 	return result.join("\n");
 }
 /**
@@ -4929,12 +4987,47 @@ function stripIgnoreRegions(lines) {
 }
 /** Scan backwards from `lineIdx` to find the nearest class declaration name. */
 function findContainingClass(lines, lineIdx) {
+	if (/^\S/.test(lines[lineIdx] ?? "")) return "";
 	for (let j = lineIdx - 1; j >= 0; j--) {
-		const m = lines[j].match(/^\s*(?:export\s+)?class\s+(\w+)/);
+		const m = lines[j].match(/^\s*(?:(?:export|public|private|protected|internal|abstract|sealed|static|partial)\s+)*class\s+(\w+)/);
 		if (m) return m[1];
 	}
 	return "";
 }
+function findContainingDescribeScope(lines, lineIdx) {
+	const markerLine = lines[lineIdx] ?? "";
+	if (/^\S/.test(markerLine)) return "";
+	const markerIndent = leadingSpaces(markerLine);
+	for (let j = lineIdx - 1; j >= 0; j--) {
+		const line = lines[j];
+		if (leadingSpaces(line) >= markerIndent) continue;
+		const match = line.match(/^\s*describe\((['"`])(.+?)\1\s*,/);
+		if (match) return match[2];
+		if (/^\s*(?:export\s+)?class\s+\w+/.test(line)) return "";
+	}
+	return "";
+}
+function findDescribeScopeEndLine(lines, scopeName) {
+	for (let i = 0; i < lines.length; i++) {
+		const match = lines[i].match(/^\s*describe\((['"`])(.+?)\1\s*,/);
+		if (!match || match[2] !== scopeName) continue;
+		let depth = 0;
+		for (let j = i; j < lines.length; j++) {
+			depth += countChar(lines[j], "{");
+			depth -= countChar(lines[j], "}");
+			if (j > i && depth <= 0) return j;
+		}
+	}
+}
+function leadingSpaces(line) {
+	return line.match(/^\s*/)?.[0].length ?? 0;
+}
+function countChar(line, char) {
+	return [...line].filter((c) => c === char).length;
+}
+function hasTopLevelDeclaration(lines) {
+	return lines.some((line) => /^(?:export\s+)?(?:interface|type|class|function|const|let|var|enum)\s+\w+/.test(line.trim()));
+}
 /**
 * Find the start line of a class declaration (including decorators above it)
 * by scanning backwards from `beforeLine`.
@@ -5012,9 +5105,13 @@ function collectTsImports(lines) {
 			const mod = m[4];
 			if (defaultName) out.defaults.set(mod, defaultName);
 			const names = namesRaw.split(",").map((s) => s.trim().replace(/\s+as\s+\w+$/, "")).filter(Boolean);
-			const target = isTypeOnly ? out.typeOnly : out.named;
-			if (!target.has(mod)) target.set(mod, /* @__PURE__ */ new Set());
-			for (const n of names) target.get(mod).add(n);
+			for (const rawName of names) {
+				const isInlineTypeOnly = rawName.startsWith("type ");
+				const name = rawName.replace(/^type\s+/, "");
+				const target = isTypeOnly || isInlineTypeOnly ? out.typeOnly : out.named;
+				if (!target.has(mod)) target.set(mod, /* @__PURE__ */ new Set());
+				target.get(mod).add(name);
+			}
 			continue;
 		}
 		m = normalized.match(/^import\s+(?:type\s+)?(\w+)\s+from\s+['"]([^'"]+)['"]$/);
@@ -5037,12 +5134,99 @@ function collectTsImports(lines) {
 *
 * Mutates `resultLines` in place.
 */
+function filterOutIgnoreRegions(lines) {
+	const out = [];
+	let skipping = false;
+	for (const line of lines) {
+		if (!skipping && line.includes("@oagen-ignore-start")) {
+			skipping = true;
+			continue;
+		}
+		if (skipping) {
+			if (line.includes("@oagen-ignore-end")) skipping = false;
+			continue;
+		}
+		out.push(line);
+	}
+	return out;
+}
+function collectIgnoreRegionUsageText(lines) {
+	const out = [];
+	let skipping = false;
+	for (const line of lines) {
+		if (!skipping && line.includes("@oagen-ignore-start")) {
+			skipping = true;
+			continue;
+		}
+		if (!skipping) continue;
+		if (/^\s*(import|from)\s/.test(line)) continue;
+		out.push(line);
+		if (line.includes("@oagen-ignore-end")) skipping = false;
+	}
+	return out.join("\n");
+}
+function removeDuplicateImportsCoveredByIgnoreBlocks(lines) {
+	const ignoredImports = /* @__PURE__ */ new Set();
+	const importStatements = collectImportStatements(lines);
+	for (const stmt of importStatements) if (stmt.inIgnore) ignoredImports.add(normalizeImportStatement(stmt.lines));
+	if (ignoredImports.size === 0) return;
+	for (const stmt of [...importStatements].reverse()) {
+		if (stmt.inIgnore) continue;
+		if (ignoredImports.has(normalizeImportStatement(stmt.lines))) lines.splice(stmt.start, stmt.end - stmt.start + 1);
+	}
+}
+function collectImportStatements(lines) {
+	const statements = [];
+	let inIgnore = false;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (!inIgnore && line.includes("@oagen-ignore-start")) {
+			inIgnore = true;
+			continue;
+		}
+		if (inIgnore && line.includes("@oagen-ignore-end")) {
+			inIgnore = false;
+			continue;
+		}
+		if (!isImportLine(line)) continue;
+		const start = i;
+		let end = i;
+		const statementLines = [line];
+		if ((line.match(/[({]/g) ?? []).length > (line.match(/[)}]/g) ?? []).length) {
+			while (end + 1 < lines.length) {
+				end++;
+				statementLines.push(lines[end]);
+				if ((lines[end].match(/[)}]/g) ?? []).length > 0 && /\bfrom\b/.test(lines[end])) break;
+			}
+			i = end;
+		}
+		statements.push({
+			start,
+			end,
+			lines: statementLines,
+			inIgnore
+		});
+	}
+	return statements;
+}
+function normalizeImportStatement(lines) {
+	return lines.join("\n").replace(/,\s*}/g, " }").replace(/\s+/g, " ").trim();
+}
+function isImportLine(line) {
+	const trimmed = line.trim();
+	return /^import(\s|$)/.test(trimmed) || /^from\s+/.test(trimmed) || /^use\s+[\w\\]/.test(trimmed) || /^require(_relative)?\s+['"]/.test(trimmed);
+}
+function identifierUsed(source, identifier) {
+	return new RegExp(`\\b${identifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`).test(source);
+}
 function spliceExtraImports(existingLines, resultLines) {
+	const existingOutsideIgnore = filterOutIgnoreRegions(existingLines);
+	const ignoreRegionText = collectIgnoreRegionUsageText(existingLines);
 	const isPythonSimpleImport = (l) => /^import\s+\w/.test(l) && !/\sfrom\s/.test(l) && !/[{}]/.test(l);
-	const existingSimple = new Set(existingLines.filter(isPythonSimpleImport).map((l) => l.trim()));
+	const existingSimple = new Set(existingOutsideIgnore.filter(isPythonSimpleImport).map((l) => l.trim()));
 	const generatedSimple = new Set(resultLines.filter(isPythonSimpleImport).map((l) => l.trim()));
 	const extraSimple = [...existingSimple].filter((l) => !generatedSimple.has(l));
-	const existingFrom = collectFromImports(existingLines);
+	const existingFrom = collectFromImports(existingOutsideIgnore);
 	const generatedFrom = collectFromImports(resultLines);
 	const allGeneratedIds = /* @__PURE__ */ new Set();
 	for (const ids of generatedFrom.values()) for (const id of ids) allGeneratedIds.add(id);
@@ -5057,29 +5241,33 @@ function spliceExtraImports(existingLines, resultLines) {
 			if (extra.length > 0) extraFromLines.push(`from ${mod} import ${extra.join(", ")}`);
 		}
 	}
-	const existingTs = collectTsImports(existingLines);
+	const existingTs = collectTsImports(existingOutsideIgnore);
 	const generatedTs = collectTsImports(resultLines);
 	const extraTsLines = [];
 	for (const mod of existingTs.sideEffects) if (!generatedTs.sideEffects.has(mod)) extraTsLines.push(`import '${mod}';`);
 	for (const [mod, name] of existingTs.defaults) {
 		if (generatedTs.defaults.has(mod)) continue;
+		if (!identifierUsed(ignoreRegionText, name)) continue;
 		extraTsLines.push(`import ${name} from '${mod}';`);
 	}
-	for (const [mod, name] of existingTs.namespaces) if (!generatedTs.namespaces.has(mod)) extraTsLines.push(`import * as ${name} from '${mod}';`);
+	for (const [mod, name] of existingTs.namespaces) {
+		if (!identifierUsed(ignoreRegionText, name)) continue;
+		if (!generatedTs.namespaces.has(mod)) extraTsLines.push(`import * as ${name} from '${mod}';`);
+	}
 	for (const [mod, existIds] of existingTs.named) {
 		const genIds = generatedTs.named.get(mod) ?? /* @__PURE__ */ new Set();
 		const genTypeIds = generatedTs.typeOnly.get(mod) ?? /* @__PURE__ */ new Set();
-		const extra = [...existIds].filter((id) => !genIds.has(id) && !genTypeIds.has(id));
+		const extra = [...existIds].filter((id) => !genIds.has(id) && !genTypeIds.has(id) && identifierUsed(ignoreRegionText, id));
 		if (extra.length > 0) extraTsLines.push(`import { ${extra.join(", ")} } from '${mod}';`);
 	}
 	for (const [mod, existIds] of existingTs.typeOnly) {
 		const genIds = generatedTs.typeOnly.get(mod) ?? /* @__PURE__ */ new Set();
 		const genNamedIds = generatedTs.named.get(mod) ?? /* @__PURE__ */ new Set();
-		const extra = [...existIds].filter((id) => !genIds.has(id) && !genNamedIds.has(id));
+		const extra = [...existIds].filter((id) => !genIds.has(id) && !genNamedIds.has(id) && identifierUsed(ignoreRegionText, id));
 		if (extra.length > 0) extraTsLines.push(`import type { ${extra.join(", ")} } from '${mod}';`);
 	}
 	const isPhpUseImport = (l) => /^use\s+[\w\\]+\\[\w\\]*(\s+as\s+\w+)?\s*;?$/.test(l);
-	const existingPhpUse = new Set(existingLines.filter(isPhpUseImport).map((l) => l.trim()));
+	const existingPhpUse = new Set(existingOutsideIgnore.filter(isPhpUseImport).map((l) => l.trim()));
 	const generatedPhpUse = new Set(resultLines.filter(isPhpUseImport).map((l) => l.trim()));
 	const extraPhpUse = [...existingPhpUse].filter((l) => !generatedPhpUse.has(l));
 	const rubyRequireRe = /^(require(?:_relative)?)\s+['"]([^'"]+)['"]\s*$/;
@@ -5094,7 +5282,7 @@ function spliceExtraImports(existingLines, resultLines) {
 	}
 	const seenExistingKeys = /* @__PURE__ */ new Set();
 	const extraRubyRequire = [];
-	for (const l of existingLines) {
+	for (const l of existingOutsideIgnore) {
 		const key = rubyRequireKey(l);
 		if (!key) continue;
 		if (generatedRubyRequireKeys.has(key)) continue;
@@ -5626,6 +5814,7 @@ async function readManifest(dir) {
 }
 /** Write `.oagen-manifest.json` to a directory with sorted paths. */
 async function writeManifest(dir, opts) {
+	const manifestPath = path$1.join(dir, MANIFEST_FILENAME);
 	const manifest = {
 		version: MANIFEST_VERSION,
 		language: opts.language,
@@ -5640,10 +5829,16 @@ async function writeManifest(dir, opts) {
 		files: [...new Set(opts.files)].sort(),
 		...opts.operations !== void 0 ? { operations: opts.operations } : {}
 	};
-	const manifestPath = path$1.join(dir, MANIFEST_FILENAME);
+	const previous = await readManifest(dir);
+	if (previous && sameManifestExceptGeneratedAt(previous, manifest)) manifest.generatedAt = previous.generatedAt;
 	await fs.mkdir(dir, { recursive: true });
 	await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
 }
+function sameManifestExceptGeneratedAt(a, b) {
+	const { generatedAt: _aGeneratedAt, ...aComparable } = a;
+	const { generatedAt: _bGeneratedAt, ...bComparable } = b;
+	return JSON.stringify(aComparable) === JSON.stringify(bComparable);
+}
 /** Return the set of previous paths no longer present in the current emission. */
 function computeStalePaths(prev, currentPaths) {
 	const current = new Set(currentPaths);