@workos/oagen 0.22.3 → 0.22.5

package/README.md

@@ -1,6 +1,6 @@
 # oagen
 
-oagen ([**oʊweɪdd͡ʒɛn**](https://ipa-reader.com/?text=o%CA%8Awe%C9%AAdd%CD%A1%CA%92%C9%9Bn)) is a framework for building custom SDK generators from OpenAPI 3.x specifications.
+oagen ([oʊweɪdd͡ʒɛn](https://ipa-reader.com/?text=o%CA%8Awe%C9%AAdd%CD%A1%CA%92%C9%9Bn)) is a framework for building custom SDK generators from OpenAPI 3.x specifications.
 
 Its core job is narrow:
 

package/dist/cli/index.mjs

@@ -4917,8 +4917,23 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 	}
 	replacements.sort((a, b) => b.startLine - a.startLine);
 	for (const rep of replacements) result.splice(rep.startLine, rep.endLine - rep.startLine, ...rep.content);
+	let regionDeclarationEdits = 0;
+	{
+		const topLevelEntries = blocksByClass.get("");
+		if (topLevelEntries) {
+			const alreadyPlaced = handledBlockKeys.has("");
+			const remaining = [];
+			for (const entry of topLevelEntries) {
+				const outcome = await applyRegionDeclarationOverride(result, entry.lines, language, !alreadyPlaced);
+				if (outcome.edited) regionDeclarationEdits++;
+				if (!alreadyPlaced && !outcome.placed) remaining.push(entry);
+			}
+			if (!alreadyPlaced) if (remaining.length === 0) blocksByClass.delete("");
+			else blocksByClass.set("", remaining);
+		}
+	}
 	let effectiveClassEndLines = classEndLines;
-	if (replacedClasses.size > 0) effectiveClassEndLines = await extractClassEndLines(result.join("\n"), language);
+	if (replacedClasses.size > 0 || regionDeclarationEdits > 0) effectiveClassEndLines = await extractClassEndLines(result.join("\n"), language);
 	const insertions = [];
 	let insertionOrder = 0;
 	for (const [className, classBlocks] of blocksByClass) {
@@ -4949,7 +4964,7 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 			}
 			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];
+			const blockContent = /^import\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,
@@ -5044,6 +5059,139 @@ function findClassDeclarationStart(lines, className, beforeLine) {
 	return -1;
 }
 /**
+* Conservative top-level declaration matcher for ignore-block content.
+* Matches column-0 declarations like `export interface X`, `type X = …`,
+* `const X = …`, `function X(…)`, `class X` (export optional). Names found
+* here are only acted on when the language's merge adapter also reports a
+* generated top-level statement with the same key, so false positives are
+* filtered by the real parser.
+*/
+const REGION_DECLARATION_PATTERN = /^(?:export\s+)?(?:declare\s+)?(?:interface|type|enum|class|const|let|var|async\s+function|function)\s+([A-Za-z_$][\w$]*)/;
+/** Extract top-level symbol names declared inside an ignore block's lines. */
+function collectRegionDeclaredNames(blockLines) {
+	const names = /* @__PURE__ */ new Set();
+	for (const line of blockLines) {
+		if (line.includes("@oagen-ignore")) continue;
+		const m = line.match(REGION_DECLARATION_PATTERN);
+		if (m) names.add(m[1]);
+	}
+	return names;
+}
+/** Inclusive line ranges of `@oagen-ignore-start`..`@oagen-ignore-end` regions. */
+function collectIgnoreRegionLineRanges(lines) {
+	const ranges = [];
+	let start = -1;
+	for (let i = 0; i < lines.length; i++) {
+		if (start === -1 && lines[i].includes("@oagen-ignore-start")) {
+			start = i;
+			continue;
+		}
+		if (start !== -1 && lines[i].includes("@oagen-ignore-end")) {
+			ranges.push({
+				start,
+				end: i
+			});
+			start = -1;
+		}
+	}
+	return ranges;
+}
+/**
+* Walk upward from a declaration's first line over its contiguous comment
+* block (doc comment), so the comment is dropped together with the
+* declaration. Stops at blank lines, region markers, and line 0 (a comment
+* on line 0 is the file header, not a docstring).
+*/
+function extendOverPrecedingComments(lines, startLine) {
+	let s = startLine;
+	while (s > 1) {
+		const prev = lines[s - 1].trim();
+		if (prev === "" || prev.includes("@oagen-ignore")) break;
+		if (!(prev.startsWith("//") || prev.startsWith("/*") || prev.startsWith("*") || prev.startsWith("#"))) break;
+		s--;
+	}
+	return s;
+}
+/**
+* Drop generated top-level declarations that are redeclared inside an ignore
+* block ("region wins"). When `placeBlock` is set and at least one generated
+* declaration matches, the block's lines replace the first match in place
+* (mirroring the class-replacement behavior above); any further matches are
+* deleted. Mutates `result` in place.
+*
+* Returns `placed` (the block content now lives in `result` and must not be
+* inserted again) and `edited` (line numbers shifted).
+*/
+async function applyRegionDeclarationOverride(result, blockLines, language, placeBlock) {
+	const names = collectRegionDeclaredNames(blockLines);
+	if (names.size === 0) return {
+		placed: false,
+		edited: false
+	};
+	const source = result.join("\n");
+	let parsed;
+	try {
+		parsed = await extractStatements(source, language);
+	} catch {
+		return {
+			placed: false,
+			edited: false
+		};
+	}
+	const regionRanges = collectIgnoreRegionLineRanges(result);
+	const inRegion = (line) => regionRanges.some((r) => line >= r.start && line <= r.end);
+	const spans = [];
+	for (const stmt of parsed.statements) {
+		if (stmt.kind !== "declaration" || !stmt.key || !names.has(stmt.key)) continue;
+		let idx = source.indexOf(stmt.text);
+		let startLine = -1;
+		while (idx !== -1) {
+			const line = source.slice(0, idx).split("\n").length - 1;
+			if (!inRegion(line)) {
+				startLine = line;
+				break;
+			}
+			idx = source.indexOf(stmt.text, idx + 1);
+		}
+		if (startLine === -1) continue;
+		const endLine = startLine + stmt.text.split("\n").length - 1;
+		spans.push({
+			start: extendOverPrecedingComments(result, startLine),
+			end: endLine
+		});
+	}
+	if (spans.length === 0) return {
+		placed: false,
+		edited: false
+	};
+	spans.sort((a, b) => a.start - b.start);
+	for (let i = spans.length - 1; i >= 1; i--) {
+		const span = spans[i];
+		let deleteCount = span.end - span.start + 1;
+		const prevBlank = span.start === 0 || (result[span.start - 1] ?? "").trim() === "";
+		const nextBlank = (result[span.end + 1] ?? "").trim() === "";
+		if (prevBlank && nextBlank && span.end + 1 < result.length) deleteCount++;
+		result.splice(span.start, deleteCount);
+	}
+	const first = spans[0];
+	if (placeBlock) {
+		result.splice(first.start, first.end - first.start + 1, ...blockLines);
+		return {
+			placed: true,
+			edited: true
+		};
+	}
+	let deleteCount = first.end - first.start + 1;
+	const prevBlank = first.start === 0 || (result[first.start - 1] ?? "").trim() === "";
+	const nextBlank = (result[first.end + 1] ?? "").trim() === "";
+	if (prevBlank && nextBlank && first.end + 1 < result.length) deleteCount++;
+	result.splice(first.start, deleteCount);
+	return {
+		placed: false,
+		edited: true
+	};
+}
+/**
 * Collect `from X import Y, Z` identifiers grouped by module, handling
 * both single-line and multiline (parenthesized) forms.
 */