@workos/oagen 0.16.0 → 0.17.0

package/dist/smoke.mjs

@@ -405,17 +405,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 = [];
@@ -782,6 +829,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,
@@ -980,8 +1072,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 [{
@@ -1078,17 +1182,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",