@workos/oagen 0.14.0 → 0.15.0

package/dist/cli/index.mjs

@@ -7221,7 +7221,10 @@ function diffSnapshots(baseline, candidate, policy) {
 		changes.push(classifyAddedSymbol(candSym));
 	}
 	detectForkedSchemas(changes, baseline, candidate);
-	cascadeRenameDowngrades(changes, detectTypeRenames(changes, baseline, candidate), detectEnumRenames(changes, baseline, candidate));
+	const typeRenames = detectTypeRenames(changes, baseline, candidate);
+	const enumRenames = detectEnumRenames(changes, baseline, candidate);
+	inferTransitiveTypeRenames(typeRenames, baseline, candidate, changes);
+	cascadeRenameDowngrades(changes, typeRenames, enumRenames, baseline, candidate);
 	return {
 		changes,
 		summary: summarizeChanges(changes)
@@ -7331,27 +7334,86 @@ function detectTypeRenames(changes, baseline, candidate) {
 	const candidateTypeFields = collectTypeFieldSets(candidate);
 	const baselineTypeNames = new Set(baselineTypeFields.keys());
 	const candidateTypesSorted = [...candidateTypeFields.entries()].sort((a, b) => a[0].localeCompare(b[0]));
-	for (const change of changes) {
-		if (change.category !== "symbol_removed") continue;
-		if (change.severity !== "breaking") continue;
-		const removedName = bareTypeName(change.old.symbol ?? "");
-		if (!removedName) continue;
-		const removedFields = baselineTypeFields.get(removedName);
-		if (!removedFields || removedFields.size === 0) continue;
+	const parentRemovalByName = /* @__PURE__ */ new Map();
+	for (const change of changes) if (change.category === "symbol_removed" && change.severity === "breaking") parentRemovalByName.set(change.old.symbol ?? "", change);
+	for (const [baselineTypeName, baselineFields] of baselineTypeFields) {
+		if (baselineFields.size === 0) continue;
+		const sameNameFields = candidateTypeFields.get(baselineTypeName);
+		if (sameNameFields && setEquals(baselineFields, sameNameFields)) continue;
 		const match = candidateTypesSorted.find(([candName, candFields]) => {
 			if (baselineTypeNames.has(candName)) return false;
-			for (const f of removedFields) if (!candFields.has(f)) return false;
+			for (const f of baselineFields) if (!candFields.has(f)) return false;
 			return true;
 		});
 		if (!match) continue;
 		const [newName] = match;
-		renameMap.set(removedName, newName);
-		change.severity = "soft-risk";
-		change.remediation = `Type "${removedName}" 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 "${removedName}" type annotations need to migrate. Consider emitting a deprecated alias \`type ${removedName} = ${newName}\` in languages that support it.`;
+		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.`;
+		}
 	}
 	return renameMap;
 }
 /**
+* Transitive rename inference. After `detectTypeRenames` records direct
+* structural matches (e.g. `ApiKeyWithValue → OrganizationApiKeyWithValue`),
+* walk the parent's fields and follow the `typeRef.name` of each: if the
+* 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.
+*
+* Why this is necessary: discriminated-union owner types (Go's
+* `APIKeyWithValueOwner`, PHP/Python's nested constructor params) are
+* frequently emitted as `kind: 'alias'` symbols with no extractable
+* field children — so `collectTypeFieldSets` returns empty for them and
+* the structural matcher can't pair them directly. The transitive
+* lookup gives us a deterministic, conservative way to propagate the
+* rename: it only fires when the parent rename has already been
+* positively identified, and only follows fields that share the same
+* wire name across baseline and candidate.
+*/
+function inferTransitiveTypeRenames(typeRenames, baseline, candidate, changes) {
+	if (typeRenames.size === 0) return;
+	const baselineFieldType = /* @__PURE__ */ new Map();
+	for (const sym of baseline.symbols) {
+		if (sym.kind !== "field" && sym.kind !== "property") continue;
+		if (!sym.ownerFqName || !sym.typeRef) continue;
+		const localName = sym.fqName.includes(".") ? sym.fqName.slice(sym.fqName.lastIndexOf(".") + 1) : sym.fqName;
+		baselineFieldType.set(`${sym.ownerFqName}.${localName.toLowerCase()}`, sym.typeRef.name);
+	}
+	const candidateFieldType = /* @__PURE__ */ new Map();
+	for (const sym of candidate.symbols) {
+		if (sym.kind !== "field" && sym.kind !== "property") continue;
+		if (!sym.ownerFqName || !sym.typeRef) continue;
+		const localName = sym.fqName.includes(".") ? sym.fqName.slice(sym.fqName.lastIndexOf(".") + 1) : sym.fqName;
+		candidateFieldType.set(`${sym.ownerFqName}.${localName.toLowerCase()}`, sym.typeRef.name);
+	}
+	const parentRemovalByName = /* @__PURE__ */ new Map();
+	for (const change of changes) if (change.category === "symbol_removed" && change.severity === "breaking") parentRemovalByName.set(change.old.symbol ?? "", change);
+	const initialEntries = [...typeRenames.entries()];
+	for (const [oldOwner, newOwner] of initialEntries) for (const [baselineKey, baselineFieldTypeRef] of baselineFieldType) {
+		if (!baselineKey.startsWith(`${oldOwner}.`)) continue;
+		const localName = baselineKey.slice(oldOwner.length + 1);
+		const candidateKey = `${newOwner}.${localName}`;
+		const candidateFieldTypeRef = candidateFieldType.get(candidateKey);
+		if (!candidateFieldTypeRef) continue;
+		const oldT = bareTypeName(baselineFieldTypeRef);
+		const newT = bareTypeName(candidateFieldTypeRef);
+		if (!oldT || !newT || oldT === newT) continue;
+		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.`;
+		}
+	}
+}
+/**
 * Detect enum canonical-flips: a baseline enum disappears and a candidate
 * enum with the **same wire-value set** takes its place.
 *
@@ -7374,24 +7436,21 @@ function detectEnumRenames(changes, baseline, candidate) {
 	const candidateEnumValues = collectEnumValueSets(candidate);
 	const baselineEnumNames = new Set(baselineEnumValues.keys());
 	const candidateEnumsSorted = [...candidateEnumValues.entries()].sort((a, b) => a[0].localeCompare(b[0]));
-	for (const change of changes) {
-		if (change.category !== "symbol_removed") continue;
-		if (change.severity !== "breaking") continue;
-		const removedName = bareTypeName(change.old.symbol ?? "");
-		if (!removedName) continue;
-		const removedValues = baselineEnumValues.get(removedName);
-		if (!removedValues || removedValues.size === 0) continue;
-		const match = candidateEnumsSorted.find(([candName, candValues]) => {
-			if (baselineEnumNames.has(candName)) return false;
-			if (candValues.size !== removedValues.size) return false;
-			for (const v of removedValues) if (!candValues.has(v)) return false;
-			return true;
-		});
+	const parentRemovalByName = /* @__PURE__ */ new Map();
+	for (const change of changes) if (change.category === "symbol_removed" && change.severity === "breaking") parentRemovalByName.set(change.old.symbol ?? "", change);
+	for (const [baselineEnumName, baselineValues] of baselineEnumValues) {
+		if (baselineValues.size === 0) continue;
+		const sameNameValues = candidateEnumValues.get(baselineEnumName);
+		if (sameNameValues && setEquals(baselineValues, sameNameValues)) continue;
+		const match = candidateEnumsSorted.find(([candName, candValues]) => !baselineEnumNames.has(candName) && setEquals(baselineValues, candValues));
 		if (!match) continue;
 		const [newName] = match;
-		renameMap.set(removedName, newName);
-		change.severity = "soft-risk";
-		change.remediation = `Enum "${removedName}" 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.`;
+		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.`;
+		}
 	}
 	return renameMap;
 }
@@ -7409,8 +7468,40 @@ function detectEnumRenames(changes, baseline, candidate) {
 * Each cascaded change gets a remediation pointing at the parent rename
 * so the reviewer can find the explanation in the report.
 */
-function cascadeRenameDowngrades(changes, typeRenames, enumRenames) {
-	if (typeRenames.size === 0 && enumRenames.size === 0) return;
+function cascadeRenameDowngrades(changes, typeRenames, enumRenames, baseline, candidate) {
+	let baselineTypeFields;
+	let candidateTypeFields;
+	const getBaselineFields = () => {
+		if (!baselineTypeFields) baselineTypeFields = collectTypeFieldSets(baseline);
+		return baselineTypeFields;
+	};
+	const getCandidateFields = () => {
+		if (!candidateTypeFields) candidateTypeFields = collectTypeFieldSets(candidate);
+		return candidateTypeFields;
+	};
+	/**
+	* Structural equivalence: candidate type's field set is a non-strict
+	* superset of baseline type's field set, AND the candidate type was
+	* newly added in this diff (not a swap to a pre-existing type, which
+	* is a real signature break the consumer chose). When `New ⊇ Old` and
+	* `New` is new, every field the consumer accessed on the old type
+	* still exists on the value they receive — so the swap is non-breaking
+	* at the value level even though the declared type changed. This is
+	* the fork-detector's positive signal, applied as a severity
+	* downgrade in addition to the existing remediation hint.
+	*/
+	const isStructurallyEquivalent = (oldT, newT) => {
+		if (!oldT || !newT || oldT === newT) return false;
+		const baselineFields = getBaselineFields();
+		const candidateFields = getCandidateFields();
+		if (baselineFields.has(newT)) return false;
+		const oldFields = baselineFields.get(oldT);
+		const newFields = candidateFields.get(newT);
+		if (!oldFields || !newFields) return false;
+		if (oldFields.size === 0) return false;
+		for (const f of oldFields) if (!newFields.has(f)) return false;
+		return true;
+	};
 	for (const change of changes) {
 		if (change.severity !== "breaking") continue;
 		if (change.category === "symbol_removed") {
@@ -7430,6 +7521,9 @@ function cascadeRenameDowngrades(changes, typeRenames, enumRenames) {
 			if (typeRenames.get(oldT) === newT) {
 				change.severity = "soft-risk";
 				change.remediation = `Return type swap matches recorded rename "${oldT}" → "${newT}". The underlying field set is preserved (see the rename advisory on "${oldT}").`;
+			} else if (isStructurallyEquivalent(oldT, newT)) {
+				change.severity = "soft-risk";
+				if (!change.remediation) change.remediation = `Return type swap from "${oldT}" to "${newT}" is structurally equivalent — every field on "${oldT}" still exists on "${newT}". Consumer code accessing fields on the returned value continues to work; only explicit "${oldT}" type annotations need to migrate.`;
 			}
 			continue;
 		}
@@ -7439,6 +7533,9 @@ function cascadeRenameDowngrades(changes, typeRenames, enumRenames) {
 			if ((typeRenames.get(oldT) ?? enumRenames.get(oldT)) === newT) {
 				change.severity = "soft-risk";
 				change.remediation = `Field type swap matches recorded rename "${oldT}" → "${newT}". On-the-wire shape is unchanged (see the rename advisory on "${oldT}").`;
+			} else if (isStructurallyEquivalent(oldT, newT)) {
+				change.severity = "soft-risk";
+				if (!change.remediation) change.remediation = `Field type swap from "${oldT}" to "${newT}" is structurally equivalent — every field on "${oldT}" still exists on "${newT}".`;
 			}
 		}
 	}
@@ -7468,6 +7565,12 @@ function collectEnumValueSets(snapshot) {
 	}
 	return result;
 }
+/** Set equality for the small string sets used by rename detection. */
+function setEquals(a, b) {
+	if (a.size !== b.size) return false;
+	for (const v of a) if (!b.has(v)) return false;
+	return true;
+}
 /**
 * Strip array/nullable suffixes so we compare bare type names. Languages
 * encode these differently (`Foo[]`, `Foo | null`, `Foo?`, `List<Foo>`,
@@ -7476,10 +7579,17 @@ function collectEnumValueSets(snapshot) {
 */
 function bareTypeName(t) {
 	let s = t.trim();
+	s = s.replace(/^\*/, "");
+	if (s.startsWith("\\")) {
+		const lastBackslash = s.lastIndexOf("\\");
+		s = s.slice(lastBackslash + 1);
+	}
 	s = s.replace(/\s*\|\s*null$/, "").replace(/\?$/, "");
 	s = s.replace(/\[\]$/, "");
-	const generic = s.match(/^[A-Za-z_][A-Za-z0-9_.]*<\s*([A-Za-z_][A-Za-z0-9_.]*)\s*>$/);
-	if (generic) s = generic[1];
+	const angleGeneric = s.match(/^[A-Za-z_][A-Za-z0-9_.]*<\s*([A-Za-z_*][A-Za-z0-9_.*]*)\s*>$/);
+	if (angleGeneric) return bareTypeName(angleGeneric[1]);
+	const bracketGeneric = s.match(/^[A-Za-z_][A-Za-z0-9_.]*\[\s*([A-Za-z_*][A-Za-z0-9_.*]*)\s*\]$/);
+	if (bracketGeneric) return bareTypeName(bracketGeneric[1]);
 	return s;
 }
 /**