@workos/oagen 0.29.3 → 0.30.0

package/dist/{diff-DqnHHXvr.mjs → diff-DMFiDAI6.mjs}

@@ -177,6 +177,43 @@ function resolveResponseModelName(op) {
 	if (ref.kind === "nullable" && ref.inner.kind === "model") return ref.inner.name;
 	return null;
 }
+/**
+* Find every pair of distinct paths that resolve to the same SDK method name.
+*
+* Emitters already refuse to generate on a collision, but they only run inside
+* the per-language build matrix — so a spec addition that collides fails every
+* matrix job minutes in, with no cheap way to catch it first. Surfacing the same
+* check from `oagen resolve` turns that into a seconds-long precheck.
+*
+* Returns every collision rather than throwing on the first, so a spec that
+* introduces several is fixed in one pass instead of one CI round-trip each.
+*
+* Callers that generate a subset of services must filter to the operations they
+* will actually emit before calling this: a collision between two out-of-scope
+* paths is not that run's problem.
+*/
+function findResolvedMethodCollisions(resolved) {
+	const seen = /* @__PURE__ */ new Map();
+	const collisions = [];
+	for (const r of resolved) {
+		const key = `${r.mountOn}.${r.methodName}`;
+		const current = {
+			httpMethod: r.operation.httpMethod.toUpperCase(),
+			path: r.operation.path
+		};
+		const existing = seen.get(key);
+		if (existing && (existing.path !== current.path || existing.httpMethod !== current.httpMethod)) {
+			collisions.push({
+				key,
+				first: existing,
+				second: current
+			});
+			continue;
+		}
+		if (!existing) seen.set(key, current);
+	}
+	return collisions;
+}
 //#endregion
 //#region src/engine/merge-adapters/url-fingerprint.ts
 /**
@@ -714,6 +751,7 @@ function extractKotlinClassMembers(classBody, source) {
 	const children = classBody.namedChildren;
 	for (let i = 0; i < children.length; i++) {
 		const child = children[i];
+		const declIndex = i;
 		let memberName = null;
 		if (child.type === "property_declaration") memberName = child.children.find((c) => c.type === "variable_declaration")?.children.find((c) => c.type === "simple_identifier")?.text ?? null;
 		else if (child.type === "function_declaration") memberName = child.children.find((c) => c.type === "simple_identifier")?.text ?? null;
@@ -728,7 +766,7 @@ function extractKotlinClassMembers(classBody, source) {
 			} else break;
 		}
 		let startIdx = child.startIndex;
-		for (let k = i - 1; k >= 0; k--) {
+		for (let k = declIndex - 1; k >= 0; k--) {
 			const prev = children[k];
 			if (prev.type === "multiline_comment") {
 				if (source.slice(prev.startIndex, prev.endIndex).startsWith("/**")) startIdx = prev.startIndex;
@@ -797,6 +835,13 @@ const kotlinMergeAdapter = {
 	isManagedMember(member) {
 		return KOTLIN_MANAGED_ACCESSOR_DOC.test(member.text);
 	},
+	importedNames(imp) {
+		const path = imp.text.replace(/^import\s+/, "").trim();
+		const alias = path.match(/\s+as\s+([A-Za-z_][A-Za-z0-9_]*)$/);
+		if (alias) return [alias[1]];
+		const last = path.split(".").pop();
+		return last && last !== "*" ? [last] : [];
+	},
 	shouldSkipDeepMerge(_symbolName, existingMemberKeys, newMembers) {
 		const newText = newMembers.map((m) => m.text).join("\n");
 		for (const match of newText.matchAll(/this\.(\w+)/g)) {
@@ -1672,6 +1717,116 @@ function declarationLineStart(content, declStartIndex) {
 	return prevNewline === -1 ? 0 : prevNewline + 1;
 }
 /**
+* Widen a member's byte range so deleting it removes whole lines.
+*
+* The raw range starts at the declaration (or its docstring), which sits after
+* the member's indentation — splicing it out verbatim leaves that indentation
+* glued to the following line. Extends backwards over the indentation and
+* forwards over the trailing newline, then absorbs the blank line the removal
+* would otherwise duplicate (or strand in front of the block's closing brace).
+*/
+function expandPruneRange(source, rawStart, rawEnd) {
+	let start = rawStart;
+	while (start > 0 && (source[start - 1] === " " || source[start - 1] === "	")) start--;
+	let end = rawEnd;
+	while (end < source.length && (source[end] === " " || source[end] === "	")) end++;
+	end = skipLineBreak(source, end);
+	if (precededByBlankLine(source, start)) {
+		if (startsWithLineBreak(source, end)) end = skipLineBreak(source, end);
+		else if (/^[ \t]*\}/.test(source.slice(end, end + 40))) start = backOverLineBreak(source, start);
+	}
+	return {
+		start,
+		end
+	};
+}
+function startsWithLineBreak(source, idx) {
+	return source[idx] === "\n" || source[idx] === "\r" && source[idx + 1] === "\n";
+}
+function skipLineBreak(source, idx) {
+	let i = idx;
+	if (source[i] === "\r") i++;
+	return source[i] === "\n" ? i + 1 : i;
+}
+function backOverLineBreak(source, idx) {
+	let i = idx;
+	if (source[i - 1] === "\n") i--;
+	if (source[i - 1] === "\r") i--;
+	return i;
+}
+/** Whether the line ending immediately before `idx` (a line start) is empty. */
+function precededByBlankLine(source, idx) {
+	if (idx === 0 || source[idx - 1] !== "\n") return false;
+	const priorLineEnd = backOverLineBreak(source, idx);
+	return priorLineEnd > 0 && source[priorLineEnd - 1] === "\n";
+}
+function referencesIdentifier(source, name) {
+	return new RegExp(`\\b${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`).test(source);
+}
+/**
+* Blank out comments and string text, preserving offsets and line structure.
+*
+* An identifier lookup over raw source can't tell a live reference from a name
+* that merely survives in prose. That distinction decides whether an import
+* stays: keeping one whose only remaining mention is a KDoc leaves an import of
+* a class the generator no longer emits, which doesn't compile — the very
+* failure the prune exists to prevent.
+*
+* Interpolated expressions are the exception: `"${Agents.NAME}"` is code that
+* sits inside a string literal, and masking it would drop an import the file
+* genuinely uses. String extents are masked around those holes, not over them.
+*
+* Grammar node names come from the adapter's `urlFingerprintConfig`, which
+* already inventories exactly these three categories per language. Comments are
+* matched structurally instead — every grammar we support names them `*comment`.
+*/
+function maskNonCode(tree, source, config) {
+	const stringNodeTypes = new Set(config?.stringNodeTypes ?? []);
+	const interpolationNodeTypes = new Set(config?.interpolationNodeTypes ?? []);
+	const spans = [];
+	const collectStringSpans = (node) => {
+		const holes = [];
+		const findHoles = (n) => {
+			if (interpolationNodeTypes.has(n.type)) {
+				holes.push([n.startIndex, n.endIndex]);
+				return;
+			}
+			for (const child of n.children) findHoles(child);
+		};
+		findHoles(node);
+		let cursor = node.startIndex;
+		for (const [holeStart, holeEnd] of holes) {
+			if (holeStart > cursor) spans.push([cursor, holeStart]);
+			cursor = holeEnd;
+		}
+		if (cursor < node.endIndex) spans.push([cursor, node.endIndex]);
+	};
+	const walk = (node) => {
+		if (node.type.includes("comment")) {
+			spans.push([node.startIndex, node.endIndex]);
+			return;
+		}
+		if (stringNodeTypes.has(node.type)) {
+			collectStringSpans(node);
+			return;
+		}
+		for (const child of node.children) walk(child);
+	};
+	walk(tree.rootNode);
+	if (spans.length === 0) return source;
+	let masked = "";
+	let cursor = 0;
+	for (const [spanStart, spanEnd] of spans) {
+		if (spanStart < cursor) continue;
+		masked += source.slice(cursor, spanStart) + source.slice(spanStart, spanEnd).replace(/[^\r\n]/g, " ");
+		cursor = spanEnd;
+	}
+	return masked + source.slice(cursor);
+}
+function removeLines(source, lines) {
+	return source.split("\n").filter((line) => !lines.has(line.trim())).join("\n");
+}
+/**
 * Resolve a docstring range by searching for the nearest matching text before
 * the declaration start. Falls back to parser-provided offsets when search fails.
 */
@@ -1886,6 +2041,7 @@ async function mergeIntoExisting(existingContent, generatedContent, language, he
 	let deepAdded = 0;
 	let deepPruned = 0;
 	const insertions = [];
+	const prunedTexts = [];
 	if (adapter.extractMembers) {
 		const parser = await getParser(language);
 		const resultTree = safeParse(parser, result);
@@ -1914,10 +2070,9 @@ async function mergeIntoExisting(existingContent, generatedContent, language, he
 			if (pruneEdits.length > 0) {
 				pruneEdits.sort((a, b) => b.start - a.start);
 				for (const edit of pruneEdits) {
-					let end = edit.end;
-					while (end < result.length && (result[end] === " " || result[end] === "	")) end++;
-					if (result[end] === "\n") end++;
-					result = result.slice(0, edit.start) + result.slice(end);
+					const { start, end } = expandPruneRange(result, edit.start, edit.end);
+					prunedTexts.push(result.slice(start, end));
+					result = result.slice(0, start) + result.slice(end);
 				}
 				deepPruned = pruneEdits.length;
 				const reTree = safeParse(parser, result);
@@ -1982,6 +2137,21 @@ async function mergeIntoExisting(existingContent, generatedContent, language, he
 			result = lines.join("\n");
 		}
 	}
+	if (prunedTexts.length > 0 && adapter.importedNames) {
+		const prunedText = prunedTexts.join("\n");
+		const codeOnly = maskNonCode(safeParse(await getParser(language), result), result, adapter.urlFingerprintConfig);
+		const orphaned = /* @__PURE__ */ new Set();
+		for (const imp of existingStatements.imports) {
+			const names = adapter.importedNames(imp);
+			if (names.length === 0) continue;
+			if (!names.some((n) => referencesIdentifier(prunedText, n))) continue;
+			const line = imp.text.trim();
+			const withoutImport = removeLines(codeOnly, new Set([line]));
+			if (names.some((n) => referencesIdentifier(withoutImport, n))) continue;
+			orphaned.add(line);
+		}
+		if (orphaned.size > 0) result = removeLines(result, orphaned);
+	}
 	let docstringUpdates = 0;
 	{
 		const parser = await getParser(language);
@@ -4282,6 +4452,6 @@ function summarize(changes) {
 	};
 }
 //#endregion
-export { resolveMountTarget as _, registerEmitter as a, integrateGeneratedFiles as c, applyFileHeaders as d, buildEmitterContext as f, deriveMethodName as g, generateFiles as h, getEmitter as i, mapFilesForTargetIntegration as l, generateAllFiles as m, buildDirectionIndex as n, generate as o, collectReferencedNames as p, directionOf as r, MANIFEST_FILENAME as s, diffSpecs as t, treeShakeFiles as u, resolveOperations as v };
+export { findResolvedMethodCollisions as _, registerEmitter as a, integrateGeneratedFiles as c, applyFileHeaders as d, buildEmitterContext as f, deriveMethodName as g, generateFiles as h, getEmitter as i, mapFilesForTargetIntegration as l, generateAllFiles as m, buildDirectionIndex as n, generate as o, collectReferencedNames as p, directionOf as r, MANIFEST_FILENAME as s, diffSpecs as t, treeShakeFiles as u, resolveMountTarget as v, resolveOperations as y };
 
-//# sourceMappingURL=diff-DqnHHXvr.mjs.map
+//# sourceMappingURL=diff-DMFiDAI6.mjs.map