@workos/oagen 0.20.0 → 0.21.0

package/dist/smoke.mjs

@@ -786,9 +786,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
 	};
 }
@@ -996,6 +997,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
@@ -1003,13 +1034,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;
 	}
@@ -1017,7 +1052,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;
@@ -1032,10 +1067,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);
@@ -1043,24 +1096,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 ?? []);
@@ -1289,9 +1421,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))
 		};
 	}