@workos/oagen 0.19.6 → 0.20.0

package/dist/cli/index.mjs

@@ -7867,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.
@@ -7884,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();
@@ -7910,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;
 }
@@ -7924,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
@@ -7968,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.`;
 	}
 }
 /**
@@ -8008,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;
 }