@workos/oagen 0.19.6 → 0.21.0

package/dist/cli/index.mjs

@@ -837,9 +837,10 @@ function collectLiteralStringConsts(variants) {
 function buildSyntheticEnumRef(values, contextName, parentModelName) {
 	const baseName = toPascalCase(contextName ?? "UnknownEnum");
 	const cleanParent = parentModelName ? stripListItemMarkers(parentModelName) : void 0;
+	const qualifiedName = cleanParent && !baseName.startsWith(cleanParent) ? `${cleanParent}${baseName}` : baseName;
 	return {
 		kind: "enum",
-		name: cleanParent && !baseName.startsWith(cleanParent) ? `${cleanParent}${baseName}` : baseName,
+		name: activeSchemaNameTransform ? activeSchemaNameTransform(qualifiedName) : qualifiedName,
 		values
 	};
 }
@@ -1047,6 +1048,36 @@ function extractAllOfModel(name, schema, schemas) {
 	};
 }
 /**
+* Walk through `allOf` wrappers to collect the effective top-level properties
+* of a schema. Stops at `oneOf` / `anyOf` boundaries — those are different
+* variant axes, not part of the same flat object.
+*
+* Used by `detectAllOfVariantDiscriminator` and `deriveDiscriminatedVariantName`
+* so a oneOf variant of the form `{ allOf: [{ properties: { … } }, { oneOf: […] }] }`
+* still surfaces its top-level `properties` (in particular its discriminator
+* `const`) instead of being treated as having none.
+*/
+function getEffectiveProperties(schema) {
+	const props = {};
+	const visit = (s) => {
+		if (s.properties) {
+			for (const [k, v] of Object.entries(s.properties)) if (!(k in props) && v) props[k] = v;
+		}
+		if (s.allOf) for (const sub of s.allOf) visit(sub);
+	};
+	visit(schema);
+	return props;
+}
+function getEffectiveConstPropertyValue(schema, property) {
+	const direct = getConstPropertyValue(schema, property);
+	if (direct !== null) return direct;
+	const effective = getEffectiveProperties(schema)[property];
+	if (!effective) return null;
+	if (typeof effective.const === "string") return effective.const;
+	if (Array.isArray(effective.enum) && effective.enum.length === 1 && typeof effective.enum[0] === "string") return effective.enum[0];
+	return null;
+}
+/**
 * Detect an implicit discriminator on an allOf+oneOf where every variant is an
 * object that pins the same property to a distinct const value. Unlike
 * detectConstPropertyDiscriminator (which requires $ref or title for variant
@@ -1054,13 +1085,17 @@ function extractAllOfModel(name, schema, schemas) {
 * using deriveDiscriminatedVariantName — matching how extractDiscriminatedAllOfVariantModels
 * names those models.
 *
+* Walks through allOf wrappers on each variant so a oneOf branch like
+*   { allOf: [{ properties: { type: { const: 'oauth' } } }, { oneOf: […] }] }
+* still surfaces `type` as a candidate discriminator.
+*
 * Returns null when no discriminator can be reliably detected.
 */
 function detectAllOfVariantDiscriminator(variants, fallbackName) {
 	if (variants.length < 2) return null;
-	const candidates = Object.keys(variants[0]?.properties ?? {});
+	const firstProps = getEffectiveProperties(variants[0] ?? {});
 	let candidateProperty = null;
-	for (const propName of candidates) if (variants.every((v) => getConstPropertyValue(v, propName) !== null)) {
+	for (const propName of Object.keys(firstProps)) if (variants.every((v) => getEffectiveConstPropertyValue(v, propName) !== null)) {
 		candidateProperty = propName;
 		break;
 	}
@@ -1068,7 +1103,7 @@ function detectAllOfVariantDiscriminator(variants, fallbackName) {
 	const mapping = {};
 	const seenModelNames = /* @__PURE__ */ new Set();
 	for (const v of variants) {
-		const value = getConstPropertyValue(v, candidateProperty);
+		const value = getEffectiveConstPropertyValue(v, candidateProperty);
 		if (value === null) return null;
 		const modelName = deriveDiscriminatedVariantName(v, fallbackName);
 		if (seenModelNames.has(modelName)) return null;
@@ -1083,10 +1118,28 @@ function detectAllOfVariantDiscriminator(variants, fallbackName) {
 function extractDiscriminatedAllOfVariantModels(schema, fallbackName) {
 	const models = [];
 	const seenNames = /* @__PURE__ */ new Set();
+	const baseProperties = {};
+	const baseRequired = /* @__PURE__ */ new Set();
+	for (const subSchema of schema.allOf ?? []) {
+		if (subSchema.oneOf) continue;
+		const flat = subSchema.allOf ? flattenVariantForExtraction(subSchema) : subSchema;
+		if (flat.properties) {
+			for (const [k, v] of Object.entries(flat.properties)) if (!(k in baseProperties) && v) baseProperties[k] = v;
+		}
+		if (flat.required) for (const r of flat.required) baseRequired.add(r);
+	}
 	for (const subSchema of schema.allOf ?? []) for (const variant of subSchema.oneOf ?? []) {
-		if (!variant.properties || variant.type !== void 0 && variant.type !== "object") continue;
+		const flat = flattenVariantForExtraction(variant);
+		if (!flat.properties || flat.type !== void 0 && flat.type !== "object") continue;
+		const mergedProperties = { ...baseProperties };
+		for (const [k, v] of Object.entries(flat.properties)) if (v) mergedProperties[k] = v;
+		const merged = {
+			type: "object",
+			properties: mergedProperties,
+			required: [...new Set([...baseRequired, ...flat.required ?? []])]
+		};
 		const variantName = deriveDiscriminatedVariantName(variant, fallbackName);
-		for (const model of extractInlineModelDeep(variantName, variant)) {
+		for (const model of extractInlineModelDeep(variantName, merged)) {
 			if (seenNames.has(model.name)) continue;
 			seenNames.add(model.name);
 			models.push(model);
@@ -1094,24 +1147,103 @@ function extractDiscriminatedAllOfVariantModels(schema, fallbackName) {
 	}
 	return models;
 }
+/**
+* Flatten a oneOf variant schema into a single object-shaped schema for
+* variant-model extraction. Recursively merges `allOf` members and folds
+* any nested `oneOf` into an inline-oneOf field group whose properties are
+* the union across sub-branches (required only when present in every
+* sub-branch). Returns the schema unchanged when no flattening is needed.
+*/
+function flattenVariantForExtraction(variant) {
+	if (!variant.allOf) return variant;
+	const mergedProperties = {};
+	const mergedRequired = /* @__PURE__ */ new Set();
+	const nestedOneOfs = [];
+	const collect = (s) => {
+		if (s.properties) {
+			for (const [k, v] of Object.entries(s.properties)) if (!(k in mergedProperties) && v) mergedProperties[k] = v;
+		}
+		if (s.required) for (const r of s.required) mergedRequired.add(r);
+		if (s.allOf) for (const sub of s.allOf) collect(sub);
+		if (s.oneOf) nestedOneOfs.push(s.oneOf);
+	};
+	collect(variant);
+	for (const branches of nestedOneOfs) {
+		const flatBranches = branches.map(flattenVariantForExtraction);
+		const branchKeys = /* @__PURE__ */ new Set();
+		for (const b of flatBranches) for (const k of Object.keys(b.properties ?? {})) branchKeys.add(k);
+		for (const key of branchKeys) {
+			const schemas = [];
+			for (const b of flatBranches) {
+				const s = b.properties?.[key];
+				if (s) schemas.push(s);
+			}
+			const merged = mergeBranchPropertySchemas(schemas);
+			if (!(key in mergedProperties)) mergedProperties[key] = merged;
+			if (flatBranches.every((b) => b.properties && key in b.properties) && flatBranches.every((b) => (b.required ?? []).includes(key))) mergedRequired.add(key);
+		}
+	}
+	return {
+		type: "object",
+		properties: mergedProperties,
+		required: [...mergedRequired]
+	};
+}
+/**
+* Merge same-named property schemas from across sub-variants. If every
+* occurrence is a boolean const, widen to plain boolean; if every occurrence
+* is a distinct string const, widen to plain string. Otherwise return the
+* first occurrence — emitters that build their own widened types (e.g. the
+* Node discriminated-models module) re-derive from the raw spec.
+*/
+function mergeBranchPropertySchemas(schemas) {
+	if (schemas.length === 0) return {};
+	if (schemas.length === 1) return schemas[0];
+	if (schemas.every((s) => s.type === "boolean" && typeof s.const === "boolean")) return {
+		type: "boolean",
+		description: schemas[0].description
+	};
+	if (schemas.every((s) => s.type === "string" && typeof s.const === "string")) {
+		const values = schemas.map((s) => s.const);
+		if (new Set(values).size === 1) return schemas[0];
+		return {
+			type: "string",
+			description: schemas[0].description
+		};
+	}
+	return schemas[0];
+}
 function deriveDiscriminatedVariantName(schema, fallbackName) {
-	if (!schema.properties) return fallbackName;
-	for (const name of [
+	const effective = getEffectiveProperties(schema);
+	if (Object.keys(effective).length === 0) return fallbackName;
+	const pickConst = (name) => {
+		const field = effective[name];
+		if (!field) return null;
+		if (typeof field.const === "string") return field.const;
+		if (field.enum && field.enum.length === 1 && typeof field.enum[0] === "string") return field.enum[0];
+		return null;
+	};
+	let constValue = null;
+	for (const preferred of [
 		"event",
 		"type",
 		"object"
 	]) {
-		const field = schema.properties[name];
-		if (!field) continue;
-		if (typeof field.const === "string") return toPascalCase(field.const);
-		if (field.enum && field.enum.length === 1 && typeof field.enum[0] === "string") return toPascalCase(field.enum[0]);
-	}
-	for (const field of Object.values(schema.properties)) {
-		if (!field) continue;
-		if (typeof field.const === "string") return toPascalCase(field.const);
-		if (field.enum && field.enum.length === 1 && typeof field.enum[0] === "string") return toPascalCase(field.enum[0]);
-	}
-	return fallbackName;
+		constValue = pickConst(preferred);
+		if (constValue) break;
+	}
+	if (constValue === null) for (const name of Object.keys(effective)) {
+		constValue = pickConst(name);
+		if (constValue) break;
+	}
+	if (constValue === null) return fallbackName;
+	const pascal = toPascalCase(constValue);
+	if (!pascal) return fallbackName;
+	if (splitWords(constValue).length >= 2) return pascal;
+	if (pascal === fallbackName) return pascal;
+	if (fallbackName.startsWith(pascal)) return fallbackName;
+	if (pascal.endsWith(fallbackName)) return pascal;
+	return `${fallbackName}${pascal}`;
 }
 function extractInlineModelDeep(name, schema) {
 	const requiredSet = new Set(schema.required ?? []);
@@ -1340,9 +1472,10 @@ function schemaToTypeRef(schema, contextName, parentModelName) {
 	if (schema.enum) {
 		const baseName = toPascalCase(contextName ?? "UnknownEnum");
 		const cleanParent = parentModelName ? stripListItemMarkers(parentModelName) : void 0;
+		const qualifiedName = cleanParent && !baseName.startsWith(cleanParent) ? `${cleanParent}${baseName}` : baseName;
 		return {
 			kind: "enum",
-			name: cleanParent && !baseName.startsWith(cleanParent) ? `${cleanParent}${baseName}` : baseName,
+			name: activeSchemaNameTransform ? activeSchemaNameTransform(qualifiedName) : qualifiedName,
 			values: schema.enum.map((v) => typeof v === "number" ? v : String(v))
 		};
 	}
@@ -5174,7 +5307,11 @@ function collectReferencedNames(services, models) {
 		for (const err of op.errors) if (err.type) collectFromTypeRef(err.type);
 		if (op.successResponses) for (const sr of op.successResponses) collectFromTypeRef(sr.type);
 	}
-	for (const model of models) if (isDiscriminatedModel(model)) referencedModels.add(model.name);
+	for (const model of models) {
+		if (isDiscriminatedModel(model)) referencedModels.add(model.name);
+		const disc = model.discriminator;
+		if (disc?.mapping) for (const variantName of Object.values(disc.mapping)) referencedModels.add(variantName);
+	}
 	const modelsByName = new Map(models.map((m) => [m.name, m]));
 	const visited = /* @__PURE__ */ new Set();
 	const queue = [...referencedModels];
@@ -7867,9 +8004,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 +8023,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 +8050,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 +8061,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 +8106,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 +8143,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;
 }