@workos/oagen 0.19.5 → 0.20.0

package/dist/cli/index.mjs

@@ -3148,11 +3148,21 @@ function extractKotlinClassMembers(classBody, source) {
 		}
 		members.push({
 			key: memberName,
-			text: source.slice(startIdx, endIdx)
+			text: source.slice(startIdx, endIdx),
+			startIndex: startIdx,
+			endIndex: endIdx
 		});
 	}
 	return members;
 }
+/**
+* KDoc signature that identifies a generator-emitted service accessor inside
+* the WorkOS class. The Kotlin client emitter writes every accessor with this
+* exact doc preamble — when the existing file carries a member with this doc
+* but the regenerated content omits it, the member is stale (its mount target
+* was remapped or removed) and gets pruned.
+*/
+const KOTLIN_MANAGED_ACCESSOR_DOC = /\/\*\*[\s\S]*?Lazily-constructed \[[^\]]+\] accessor for this \[WorkOS\] client\.[\s\S]*?\*\//;
 const kotlinMergeAdapter = {
 	language: "kotlin",
 	grammarModule: "tree-sitter-kotlin",
@@ -3193,6 +3203,9 @@ const kotlinMergeAdapter = {
 	renderImports(imports) {
 		return imports.map((entry) => entry.text);
 	},
+	isManagedMember(member) {
+		return KOTLIN_MANAGED_ACCESSOR_DOC.test(member.text);
+	},
 	shouldSkipDeepMerge(_symbolName, existingMemberKeys, newMembers) {
 		const newText = newMembers.map((m) => m.text).join("\n");
 		for (const match of newText.matchAll(/this\.(\w+)/g)) {
@@ -4288,6 +4301,7 @@ async function mergeIntoExisting(existingContent, generatedContent, language, he
 	let result = existingContent;
 	if (toAppend.length > 0) result = result.trimEnd() + "\n\n" + toAppend.join("\n\n") + "\n";
 	let deepAdded = 0;
+	let deepPruned = 0;
 	const insertions = [];
 	if (adapter.extractMembers) {
 		const parser = await getParser(language);
@@ -4297,6 +4311,37 @@ async function mergeIntoExisting(existingContent, generatedContent, language, he
 		const generatedSymbols = adapter.extractMembers(generatedTree, generatedContent);
 		const existingTree = safeParse(parser, existingContent);
 		const deepIgnoredSymbols = buildIgnoredSymbolNames(adapter.extractDocstrings(existingTree, existingContent), findIgnoredRegions(existingContent));
+		if (adapter.isManagedMember) {
+			const pruneEdits = [];
+			for (const [symbolName, genSymbol] of generatedSymbols) {
+				if (deepIgnoredSymbols.has(symbolName)) continue;
+				const existSymbol = resultSymbols.get(symbolName);
+				if (!existSymbol) continue;
+				const genMemberKeys = new Set(genSymbol.members.map((m) => m.key));
+				for (const existMember of existSymbol.members) {
+					if (genMemberKeys.has(existMember.key)) continue;
+					if (existMember.startIndex === void 0 || existMember.endIndex === void 0) continue;
+					if (!adapter.isManagedMember(existMember)) continue;
+					pruneEdits.push({
+						start: existMember.startIndex,
+						end: existMember.endIndex
+					});
+				}
+			}
+			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);
+				}
+				deepPruned = pruneEdits.length;
+				const reTree = safeParse(parser, result);
+				resultSymbols.clear();
+				for (const [k, v] of adapter.extractMembers(reTree, result)) resultSymbols.set(k, v);
+			}
+		}
 		for (const [symbolName, genSymbol] of generatedSymbols) {
 			if (deepIgnoredSymbols.has(symbolName)) continue;
 			const existSymbol = resultSymbols.get(symbolName);
@@ -4479,7 +4524,7 @@ async function mergeIntoExisting(existingContent, generatedContent, language, he
 		}
 	}
 	const totalAdded = (toAppend.length > 0 || deepAdded > 0 ? adapter.renderImports ? adapter.renderImports(newImports).length : newImports.length : 0) + toAppend.length + deepAdded;
-	if (totalAdded === 0 && docstringUpdates === 0) return {
+	if (totalAdded === 0 && docstringUpdates === 0 && deepPruned === 0) return {
 		content: existingContent,
 		added: 0,
 		preserved,
@@ -7822,9 +7867,11 @@ function collectTypeFieldSets(snapshot) {
 * (e.g. `ApiKey` → `OrganizationApiKey` + `UserApiKey`). The wire shape
 * returned by individual endpoints is unchanged — `OrganizationApiKey`
 * has the same fields `ApiKey` had — so consumer code accessing those
-* fields keeps working. The compat report flags `ApiKey` as removed
-* because its symbol is gone; this pass downgrades the removal to
-* soft-risk and records the rename so its child fields/methods cascade.
+* fields *through a return value* keeps working. The parent symbol
+* itself, however, is gone: callers who referenced it by name (Sorbet
+* annotations, `is_a?` checks, pattern matches, deserialization targets)
+* will fail at runtime. The parent removal therefore stays `breaking`;
+* we only attach a remediation hint pointing at the new name.
 *
 * Identity criteria (must all hold):
 *   1. The removed symbol owns ≥ 1 field/property in the baseline (i.e.
@@ -7839,10 +7886,11 @@ function collectTypeFieldSets(snapshot) {
 *
 * Returns a `removedName -> newName` map so a downstream cascade pass
 * can downgrade owned-field removals and `*_type_changed` pointing at
-* the same pair.
+* the same pair — those *are* downgraded to `soft-risk`, since values
+* flowing through the new type continue to expose the same fields.
 *
-* Mutates matching `symbol_removed` entries in `changes`: severity →
-* `soft-risk`, attaches a `remediation` describing the rename.
+* Mutates matching `symbol_removed` entries in `changes`: attaches a
+* `remediation` describing the rename. Severity is left at `breaking`.
 */
 function detectTypeRenames(changes, baseline, candidate) {
 	const renameMap = /* @__PURE__ */ new Map();
@@ -7865,10 +7913,7 @@ function detectTypeRenames(changes, baseline, candidate) {
 		const [newName] = match;
 		renameMap.set(baselineTypeName, newName);
 		const parentRemoval = parentRemovalByName.get(baselineTypeName);
-		if (parentRemoval) {
-			parentRemoval.severity = "soft-risk";
-			parentRemoval.remediation = `Type "${baselineTypeName}" appears to have been renamed to "${newName}" — the new type has every field of the old (a non-strict superset). Field accesses and method calls on values of type "${newName}" continue to work; only explicit "${baselineTypeName}" type annotations need to migrate. Consider emitting a deprecated alias \`type ${baselineTypeName} = ${newName}\` in languages that support it.`;
-		}
+		if (parentRemoval) parentRemoval.remediation = `Type "${baselineTypeName}" appears to have been renamed to "${newName}" — the new type has every field of the old (a non-strict superset). Field accesses and method calls on values of type "${newName}" continue to work; only explicit "${baselineTypeName}" type annotations need to migrate. Consider emitting a deprecated alias \`type ${baselineTypeName} = ${newName}\` in languages that support it.`;
 	}
 	return renameMap;
 }
@@ -7879,8 +7924,9 @@ function detectTypeRenames(changes, baseline, candidate) {
 * baseline parent's field references an alias-type `OldOwner` and the new
 * parent's same-named field references a different alias `NewOwner`, the
 * pair is the same type-concept under a renamed name. Record the
-* secondary rename so the cascade can downgrade `OldOwner`'s
-* `symbol_removed` and any `field_type_changed` pointing at the pair.
+* secondary rename so the cascade can downgrade any `field_type_changed`
+* pointing at the pair, and attach a remediation hint to `OldOwner`'s
+* `symbol_removed` (which stays `breaking` — see `detectTypeRenames`).
 *
 * Why this is necessary: discriminated-union owner types (Go's
 * `APIKeyWithValueOwner`, PHP/Python's nested constructor params) are
@@ -7923,10 +7969,7 @@ function inferTransitiveTypeRenames(typeRenames, baseline, candidate, changes) {
 		if (typeRenames.has(oldT)) continue;
 		typeRenames.set(oldT, newT);
 		const removal = parentRemovalByName.get(oldT);
-		if (removal) {
-			removal.severity = "soft-risk";
-			removal.remediation = `Type "${oldT}" appears to have been renamed to "${newT}" — inferred transitively because the renamed parent "${oldOwner}" → "${newOwner}" has a "${localName}" field whose type swapped from "${oldT}" to "${newT}". Consider emitting a deprecated alias \`type ${oldT} = ${newT}\` in languages that support it.`;
-		}
+		if (removal) removal.remediation = `Type "${oldT}" appears to have been renamed to "${newT}" — inferred transitively because the renamed parent "${oldOwner}" → "${newOwner}" has a "${localName}" field whose type swapped from "${oldT}" to "${newT}". Consider emitting a deprecated alias \`type ${oldT} = ${newT}\` in languages that support it.`;
 	}
 }
 /**
@@ -7963,10 +8006,7 @@ function detectEnumRenames(changes, baseline, candidate) {
 		const [newName] = match;
 		renameMap.set(baselineEnumName, newName);
 		const parentRemoval = parentRemovalByName.get(baselineEnumName);
-		if (parentRemoval) {
-			parentRemoval.severity = "soft-risk";
-			parentRemoval.remediation = `Enum "${baselineEnumName}" appears to have been renamed to "${newName}" — both enums have identical wire values, so on-the-wire serialization is unchanged. This is typically the emitter's dedup canonical-flip after a new same-shape enum joined the spec. Consider emitting a deprecated alias in languages that support it, or pinning the canonical via emitter config.`;
-		}
+		if (parentRemoval) parentRemoval.remediation = `Enum "${baselineEnumName}" appears to have been renamed to "${newName}" — both enums have identical wire values, so on-the-wire serialization is unchanged. This is typically the emitter's dedup canonical-flip after a new same-shape enum joined the spec. Consider emitting a deprecated alias in languages that support it, or pinning the canonical via emitter config.`;
 	}
 	return renameMap;
 }