@workos/oagen 0.16.0 → 0.17.1

package/dist/scripts/smoke/baseline.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 = [];
@@ -436,6 +483,14 @@ function buildInlineModel(name, schema) {
 * to apply the same name transform to $ref model/enum references.
 */
 let activeSchemaNameTransform = null;
+/**
+* Module-level set of resolved schema names whose components/schemas entry is
+* an enum (i.e. has `enum:`). Populated by extractSchemas() so schemaToTypeRef()
+* can classify a `$ref` to a top-level enum schema as `kind: 'enum'` instead of
+* `kind: 'model'`. Without this, every `$ref` was naively returned as a model
+* ref, even when the target was a shared enum like `PaginationOrder`.
+*/
+let activeEnumSchemaNames = /* @__PURE__ */ new Set();
 /** Apply cleanSchemaName + the active transform (if any) to a raw schema name. */
 function resolveSchemaName(rawName) {
 	let name = cleanSchemaName(toPascalCase(rawName));
@@ -461,6 +516,8 @@ function extractSchemas(schemas, options) {
 		for (const [, originals] of transformedToOriginals) if (originals.length > 1) for (const n of originals) unsafeToTransform.add(n);
 		activeSchemaNameTransform = (name) => unsafeToTransform.has(name) ? name : transform(name);
 	} else activeSchemaNameTransform = null;
+	activeEnumSchemaNames = /* @__PURE__ */ new Set();
+	for (const [name, schema] of Object.entries(schemas)) if (schema.enum) activeEnumSchemaNames.add(resolveSchemaName(name));
 	const modelsByCleanName = /* @__PURE__ */ new Map();
 	for (const [name, schema] of Object.entries(schemas)) {
 		const pascalName = resolveSchemaName(name);
@@ -495,6 +552,7 @@ function extractSchemas(schemas, options) {
 /** Clear the module-level schemaNameTransform. Called by parseSpec() after all extraction phases. */
 function clearSchemaNameTransform() {
 	activeSchemaNameTransform = null;
+	activeEnumSchemaNames = /* @__PURE__ */ new Set();
 }
 /**
 * Walk a single TypeRef and extract inline enum refs as top-level enum definitions.
@@ -782,6 +840,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 +1083,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 [{
@@ -1002,9 +1117,14 @@ function schemaToTypeRef(schema, contextName, parentModelName) {
 	if (schema.$ref) {
 		const segments = schema.$ref.split("/");
 		const rawName = segments[segments.length - 1];
+		const resolved = resolveSchemaName(rawName);
+		if (activeEnumSchemaNames.has(resolved)) return {
+			kind: "enum",
+			name: resolved
+		};
 		return {
 			kind: "model",
-			name: resolveSchemaName(rawName)
+			name: resolved
 		};
 	}
 	if (Array.isArray(schema.type)) {
@@ -1078,17 +1198,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",
@@ -1660,10 +1812,23 @@ function inferServiceName(path, tag) {
 	if (first.startsWith("{")) return "Default";
 	return toPascalCase(first);
 }
+/**
+* Strip overload indices (e.g. NestJS emits `Foo_bar[0]` when a controller
+* method handles multiple routes) from an operationId so derived names never
+* leak the bracketed digit. Without this, `authenticate[0]` would surface as
+* `authenticate0` in method names and `Authenticate0Request` in body model
+* names. Brackets at the end (or with trailing whitespace) are common in
+* NestJS-style backends; this regex is intentionally narrow to avoid eating
+* legitimate digits like `oauth2`.
+*/
+function normalizeOperationIdForNaming(operationId) {
+	return operationId.replace(/\[\d+\]\s*$/, "");
+}
 function inferOperationName(method, path, operationId, operationIdTransform) {
 	if (operationId) {
-		if (operationIdTransform) return operationIdTransform(operationId);
-		return toCamelCase(operationId);
+		const normalized = normalizeOperationIdForNaming(operationId);
+		if (operationIdTransform) return operationIdTransform(normalized);
+		return toCamelCase(normalized);
 	}
 	const verb = inferVerb(method, path);
 	const resource = inferResourceFromPath(path);
@@ -1981,7 +2146,7 @@ function extractRequestBody(body, op, inlineModels) {
 		};
 		return {};
 	}
-	const contextName = cleanSchemaName(op?.operationId ? toPascalCase(op.operationId) + "Request" : "RequestBody");
+	const contextName = cleanSchemaName(op?.operationId ? toPascalCase(normalizeOperationIdForNaming(op.operationId)) + "Request" : "RequestBody");
 	if (schema.properties && (schema.type === "object" || !schema.type)) {
 		const requiredSet = new Set(schema.required ?? []);
 		const fields = [];
@@ -2062,7 +2227,7 @@ function deriveOneOfVariantName(variant, baseName, existingModels) {
 	return name;
 }
 function deriveResponseName(op, path, method) {
-	if (op?.operationId) return cleanSchemaName(toPascalCase(op.operationId) + "Response");
+	if (op?.operationId) return cleanSchemaName(toPascalCase(normalizeOperationIdForNaming(op.operationId)) + "Response");
 	return toPascalCase(path.split("/").filter(Boolean)[0] ?? "Unknown") + toPascalCase(method) + "Response";
 }
 function extractResponses(responses, op, path, method) {