@workos/oagen 0.5.0 → 0.6.0

package/dist/scripts/smoke/baseline.mjs

@@ -629,6 +629,86 @@ function buildFieldFromSchema(fieldName, fieldSchema, contextName, requiredSet)
 		example: fieldSchema.example
 	};
 }
+/**
+* If every non-null oneOf/anyOf variant is a string-valued const, return the
+* list of those const values so the union can collapse into a single enum.
+* Returns null when any variant isn't a pure string-const (model ref,
+* number const, nullable, etc.).
+*/
+function collectLiteralStringConsts(variants) {
+	if (variants.length === 0) return null;
+	const values = [];
+	for (const v of variants) {
+		if (typeof v.const === "string") {
+			values.push(v.const);
+			continue;
+		}
+		if (Array.isArray(v.enum) && v.enum.length === 1 && typeof v.enum[0] === "string") {
+			values.push(v.enum[0]);
+			continue;
+		}
+		return null;
+	}
+	return values;
+}
+/** Build an EnumRef the same way the regular enum path does for naming. */
+function buildSyntheticEnumRef(values, contextName, parentModelName) {
+	const baseName = toPascalCase(contextName ?? "UnknownEnum");
+	const cleanParent = parentModelName ? stripListItemMarkers(parentModelName) : void 0;
+	return {
+		kind: "enum",
+		name: cleanParent && !baseName.startsWith(cleanParent) ? `${cleanParent}${baseName}` : baseName,
+		values
+	};
+}
+/**
+* Detect an implicit discriminator on an oneOf where every variant is an
+* object schema that pins the same property to a const value. Returns
+* { property, mapping } so the IR can represent the union as discriminated
+* without needing an explicit `discriminator:` key in the spec.
+*
+* Both shapes are supported:
+*   { properties: { event: { const: "x" } }, required: ["event"] }
+*   { properties: { event: { type: "string", enum: ["x"] } } }
+*
+* Returns null when any variant doesn't fit the pattern or when variants
+* disagree on which property carries the discriminator.
+*/
+function detectConstPropertyDiscriminator(variants) {
+	if (variants.length < 2) return null;
+	let candidateProperty = null;
+	const candidates = Object.keys(variants[0]?.properties ?? {});
+	for (const propName of candidates) if (variants.every((v) => getConstPropertyValue(v, propName) !== null)) {
+		candidateProperty = propName;
+		break;
+	}
+	if (!candidateProperty) return null;
+	const mapping = {};
+	for (const v of variants) {
+		const value = getConstPropertyValue(v, candidateProperty);
+		if (value === null) return null;
+		const variantName = resolveVariantModelName(v);
+		if (!variantName) return null;
+		mapping[value] = variantName;
+	}
+	return {
+		property: candidateProperty,
+		mapping
+	};
+}
+function getConstPropertyValue(schema, property) {
+	const prop = schema.properties?.[property];
+	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;
+}
+function resolveVariantModelName(schema) {
+	if (schema.$ref) return resolveSchemaName(schema.$ref.replace(/^#\/components\/schemas\//, ""));
+	const title = typeof schema["title"] === "string" ? schema["title"] : null;
+	if (title) return resolveSchemaName(title);
+	return null;
+}
 function extractEnum(name, schema) {
 	return {
 		name,
@@ -852,6 +932,15 @@ function schemaToTypeRef(schema, contextName, parentModelName) {
 			kind: "nullable",
 			inner: schemaToTypeRef(nonNullVariants[0], contextName, parentModelName)
 		};
+		const literalStrings = collectLiteralStringConsts(nonNullVariants);
+		if (literalStrings !== null && literalStrings.length >= 2) {
+			const enumRef = buildSyntheticEnumRef(literalStrings, contextName, parentModelName);
+			return nullVariant ? {
+				kind: "nullable",
+				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));
 		const hasNull = !!nullVariant;
 		const union = {
@@ -861,7 +950,7 @@ function schemaToTypeRef(schema, contextName, parentModelName) {
 			...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 } : {}
 		};
 		return hasNull ? {
 			kind: "nullable",