@workos/oagen 0.15.0 → 0.17.0

package/dist/cli/index.mjs

@@ -456,17 +456,64 @@ function extractInlineModelsFromProperties(schema, results, parentName) {
 			}
 		}
 		if (fieldSchema.oneOf) {
-			const objectVariant = fieldSchema.oneOf.find((v) => v.properties && (v.type === "object" || !v.type));
-			if (objectVariant) {
+			const inlineObjectVariants = fieldSchema.oneOf.filter((v) => !v.$ref && v.properties && (v.type === "object" || !v.type));
+			if (inlineObjectVariants.length > 0) {
 				const modelName = qualifyInlineModelName(toPascalCase(fieldName), parentName);
-				if (!new Set(results.map((r) => r.name)).has(modelName)) {
-					results.push(buildInlineModel(modelName, objectVariant));
-					extractInlineModelsFromProperties(objectVariant, results, modelName);
+				const existingNames = new Set(results.map((r) => r.name));
+				const namingDiscProp = deriveOneOfNamingDiscriminator(inlineObjectVariants);
+				const emittedNames = [];
+				for (const variant of inlineObjectVariants) {
+					const variantName = nameOneOfVariant(variant, modelName, emittedNames, namingDiscProp);
+					emittedNames.push(variantName);
+					if (!existingNames.has(variantName)) {
+						existingNames.add(variantName);
+						results.push(buildInlineModel(variantName, variant));
+						extractInlineModelsFromProperties(variant, results, variantName);
+					}
 				}
 			}
 		}
 	}
 }
+/** Find a single string-const-valued property shared by every variant whose
+*  values are all distinct — the implicit discriminator. Returns null when no
+*  such property exists. Mirrors `deriveConstNamingDiscriminator` in schemas.ts. */
+function deriveOneOfNamingDiscriminator(variants) {
+	if (variants.length < 2) return null;
+	const candidates = Object.keys(variants[0]?.properties ?? {});
+	for (const propName of candidates) {
+		const values = variants.map((v) => readConstString(v.properties?.[propName]));
+		if (values.some((v) => v === null)) continue;
+		if (new Set(values).size !== values.length) continue;
+		return propName;
+	}
+	return null;
+}
+function readConstString(prop) {
+	if (!prop) return null;
+	if (typeof prop.const === "string") return prop.const;
+	if (Array.isArray(prop.enum) && prop.enum.length === 1 && typeof prop.enum[0] === "string") return prop.enum[0];
+	return null;
+}
+/** Produce a per-variant model name. Variant 0 keeps the bare parent name;
+*  later variants are prefixed by the const-derived label. Mirrors
+*  `nameVariantModel` in schemas.ts. Falls back to a numeric suffix when no
+*  discriminator is available, the const value PascalCases to nothing, or
+*  the derived candidate collides with the parent or an already-emitted name. */
+function nameOneOfVariant(variant, parentName, alreadyEmitted, discriminatorProperty) {
+	if (alreadyEmitted.length === 0) return parentName;
+	if (discriminatorProperty) {
+		const constValue = readConstString(variant.properties?.[discriminatorProperty]);
+		if (constValue) {
+			const prefix = toPascalCase(constValue);
+			if (prefix) {
+				const candidate = parentName.startsWith(prefix) ? parentName : `${prefix}${parentName}`;
+				if (!(candidate === parentName || alreadyEmitted.includes(candidate))) return candidate;
+			}
+		}
+	}
+	return `${parentName}${alreadyEmitted.length + 1}`;
+}
 function buildInlineModel(name, schema) {
 	const requiredSet = new Set(schema.required ?? []);
 	const fields = [];
@@ -628,6 +675,7 @@ function findNestedFieldSchema(fieldName, parentSchema, schemas) {
 function extractNestedSchema(name, schema) {
 	if (schema.oneOf) {
 		const models = [];
+		const constNamingDiscriminator = deriveConstNamingDiscriminator(schema.oneOf.filter((v) => !v.$ref && v.properties && (v.type === "object" || !v.type)));
 		for (const variant of schema.oneOf) {
 			if (variant.$ref) continue;
 			if (variant.properties && (variant.type === "object" || !variant.type)) {
@@ -637,7 +685,7 @@ function extractNestedSchema(name, schema) {
 					if (!fs) continue;
 					fields.push(buildFieldFromSchema(fn, fs, name, requiredSet));
 				}
-				const variantName = models.length === 0 ? name : `${name}${models.length + 1}`;
+				const variantName = nameVariantModel(variant, name, models, constNamingDiscriminator);
 				models.push({
 					name: variantName,
 					description: variant.description,
@@ -675,6 +723,69 @@ function extractNestedSchema(name, schema) {
 	}
 	return [];
 }
+/**
+* Derive a meaningful name for a oneOf object variant past the first,
+* falling back to the numeric-suffix scheme (`Foo2`, `Foo3`) when no
+* better signal is available. The "better signal" is a const-valued
+* discriminator property that distinguishes one variant from the others.
+*
+* For a schema like `ApiKey.owner` whose oneOf has two variants — one
+* with `type: { const: "organization" }` and one with `type: { const:
+* "user" }` — this returns `ApiKeyOwner` for the first variant (the
+* baseline name that the union TypeRef will reference, so consumer-
+* visible typed fields stay backward-compatible) and `UserApiKeyOwner`
+* for the second instead of `ApiKeyOwner2`. SDK consumers reading the
+* generated types can tell the variants apart at a glance.
+*
+* The first variant always keeps the bare parent name because
+* `schemaToTypeRef` builds union variants whose model refs collapse to
+* `qualifyInlineModelName(field, parent)` — so the first model name
+* must match for the union's degenerate-collapse to land on a valid
+* type. Renaming variant 0 would orphan it.
+*
+* Falls back to numeric suffix when:
+*   - The variant has no discriminator property (no shared const
+*     property across all object variants), OR
+*   - The const value PascalCases to an empty/whitespace name, OR
+*   - The derived name collides with the parent name or an already-
+*     emitted variant name (numeric keeps uniqueness).
+*/
+function nameVariantModel(variant, parentName, alreadyEmitted, discriminator) {
+	if (alreadyEmitted.length === 0) return parentName;
+	if (discriminator) {
+		const constValue = getConstPropertyValue(variant, discriminator.property);
+		if (constValue) {
+			const prefix = toPascalCase(constValue);
+			if (prefix) {
+				const candidate = parentName.startsWith(prefix) ? parentName : `${prefix}${parentName}`;
+				if (!(candidate === parentName || alreadyEmitted.some((m) => m.name === candidate))) return candidate;
+			}
+		}
+	}
+	return `${parentName}${alreadyEmitted.length + 1}`;
+}
+/**
+* Returns a discriminator descriptor when every inline object variant in a
+* oneOf has a string-const value on the same property — the signature of a
+* discriminated union without an explicit `discriminator:` keyword. Used by
+* `nameVariantModel` to derive variant names from the const values.
+*
+* Distinct from `detectConstPropertyDiscriminator` (which requires every
+* variant to carry a `$ref` or `title` so a name mapping can be built):
+* this pass operates on inline anonymous variants, where naming is exactly
+* what we're trying to derive.
+*/
+function deriveConstNamingDiscriminator(variants) {
+	if (variants.length < 2) return null;
+	const candidates = Object.keys(variants[0]?.properties ?? {});
+	for (const propName of candidates) {
+		const values = variants.map((v) => getConstPropertyValue(v, propName));
+		if (values.some((v) => v === null)) continue;
+		if (new Set(values).size !== values.length) continue;
+		return { property: propName };
+	}
+	return null;
+}
 /** Build a single Field from a schema property entry. Shared across all extraction sites. */
 function buildFieldFromSchema(fieldName, fieldSchema, contextName, requiredSet) {
 	return {
@@ -769,6 +880,51 @@ function resolveVariantModelName(schema) {
 	if (title) return resolveSchemaName(title);
 	return null;
 }
+/** Look up the discriminator's mapped variant name for an inline object
+*  variant by reading its const-valued discriminator property. Returns null
+*  when the variant doesn't pin the property to a string const, or when
+*  the value isn't in the mapping. */
+function mapVariantToDiscriminatorEntry(variant, discriminator) {
+	const value = getConstPropertyValue(variant, discriminator.property);
+	if (value === null) return null;
+	return discriminator.mapping[value] ?? null;
+}
+/**
+* Derive a discriminator value → variant model name mapping for an inline-
+* variant `oneOf` whose explicit `discriminator:` has no `mapping:` clause.
+*
+* Each variant model name is reproduced via `nameVariantModel` so it matches
+* what `extractNestedSchema` registered when it walked the same `oneOf` to
+* pull variants out as named models. Variant 0 keeps the bare parent name
+* (e.g. `ApiKeyOwner`); subsequent variants get a const-derived prefix
+* (e.g. `UserApiKeyOwner` for the `type: const: user` variant).
+*
+* The "parent name" used here mirrors the one `collectNestedInlineModels`
+* passes to `extractNestedSchema`: it's the qualified inline model name
+* built from `contextName` (the field name) plus `parentModelName` (the
+* containing model). Returns null when any non-object variant is present
+* or when a variant lacks a const value on the discriminator property.
+*/
+function deriveInlineVariantMapping(variants, discriminatorProperty, contextName, parentModelName) {
+	if (variants.length === 0 || !contextName) return null;
+	const inlineObjectVariants = variants.filter((v) => !v.$ref && v.properties && (v.type === "object" || !v.type));
+	if (inlineObjectVariants.length !== variants.length) return null;
+	const baseInlineName = qualifyInlineModelName(toPascalCase(contextName), parentModelName);
+	const namingDiscriminator = { property: discriminatorProperty };
+	const mapping = {};
+	const emittedSoFar = [];
+	for (const variant of inlineObjectVariants) {
+		const constValue = getConstPropertyValue(variant, discriminatorProperty);
+		if (constValue === null) return null;
+		const variantName = nameVariantModel(variant, baseInlineName, emittedSoFar, namingDiscriminator);
+		mapping[constValue] = variantName;
+		emittedSoFar.push({
+			name: variantName,
+			fields: []
+		});
+	}
+	return mapping;
+}
 function extractEnum(name, schema) {
 	return {
 		name,
@@ -967,8 +1123,20 @@ function extractInlineModelDeep(name, schema) {
 			}));
 		}
 		if (fieldSchema.oneOf) {
-			const objectVariant = fieldSchema.oneOf.find((v) => v.properties && (v.type === "object" || !v.type));
-			if (objectVariant) nestedModels.push(...extractInlineModelDeep(qualifyNestedInlineName(name, fieldName), objectVariant));
+			const inlineObjectVariants = fieldSchema.oneOf.filter((v) => !v.$ref && v.properties && (v.type === "object" || !v.type));
+			if (inlineObjectVariants.length > 0) {
+				const baseQualified = qualifyNestedInlineName(name, fieldName);
+				const namingDisc = deriveConstNamingDiscriminator(inlineObjectVariants);
+				const emitted = [];
+				for (const variant of inlineObjectVariants) {
+					const variantName = nameVariantModel(variant, baseQualified, emitted, namingDisc);
+					emitted.push({
+						name: variantName,
+						fields: []
+					});
+					nestedModels.push(...extractInlineModelDeep(variantName, variant));
+				}
+			}
 		}
 	}
 	return [{
@@ -1065,17 +1233,49 @@ function schemaToTypeRef(schema, contextName, parentModelName) {
 				inner: enumRef
 			} : enumRef;
 		}
-		const syntheticDiscriminator = !schema.discriminator && compositionKind === "oneOf" ? detectConstPropertyDiscriminator(nonNullVariants) : null;
-		const variants = rawVariants.filter((v) => v.type !== "null").map((v) => schemaToTypeRef(v, contextName, parentModelName));
+		let resolvedDiscriminator;
+		if (schema.discriminator) {
+			const property = schema.discriminator.propertyName;
+			const explicitMapping = schema.discriminator.mapping ?? {};
+			let mapping = Object.fromEntries(Object.entries(explicitMapping).map(([k, v]) => [k, v.replace(/^#\/components\/schemas\//, "")]));
+			if (Object.keys(mapping).length === 0) {
+				const inlineMapping = deriveInlineVariantMapping(nonNullVariants, property, contextName, parentModelName);
+				if (inlineMapping) mapping = inlineMapping;
+			}
+			resolvedDiscriminator = {
+				property,
+				mapping
+			};
+		} else if (compositionKind === "oneOf") {
+			const synthetic = detectConstPropertyDiscriminator(nonNullVariants);
+			if (synthetic) resolvedDiscriminator = synthetic;
+			else {
+				const namingDisc = deriveConstNamingDiscriminator(nonNullVariants);
+				if (namingDisc) {
+					const inlineMapping = deriveInlineVariantMapping(nonNullVariants, namingDisc.property, contextName, parentModelName);
+					if (inlineMapping) resolvedDiscriminator = {
+						property: namingDisc.property,
+						mapping: inlineMapping
+					};
+				}
+			}
+		}
+		const variants = [];
+		for (const v of rawVariants) {
+			if (v === nullVariant) continue;
+			const inlineMappingName = resolvedDiscriminator && !v.$ref && v.properties && (v.type === "object" || !v.type) ? mapVariantToDiscriminatorEntry(v, resolvedDiscriminator) : null;
+			if (inlineMappingName) variants.push({
+				kind: "model",
+				name: inlineMappingName
+			});
+			else variants.push(schemaToTypeRef(v, contextName, parentModelName));
+		}
 		const hasNull = !!nullVariant;
 		const union = {
 			kind: "union",
 			variants,
 			compositionKind,
-			...schema.discriminator ? { discriminator: {
-				property: schema.discriminator.propertyName,
-				mapping: Object.fromEntries(Object.entries(schema.discriminator.mapping ?? {}).map(([k, v]) => [k, v.replace(/^#\/components\/schemas\//, "")]))
-			} } : syntheticDiscriminator ? { discriminator: syntheticDiscriminator } : {}
+			...resolvedDiscriminator ? { discriminator: resolvedDiscriminator } : {}
 		};
 		return hasNull ? {
 			kind: "nullable",