@workos/oagen-emitters 0.7.5 → 0.8.0

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.7.5"
+  ".": "0.8.0"
 }

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.8.0](https://github.com/workos/oagen-emitters/compare/v0.7.5...v0.8.0) (2026-05-05)
+
+
+### Features
+
+* **emitters:** dispatch field-level discriminated unions and drop dead request bodies ([#81](https://github.com/workos/oagen-emitters/issues/81)) ([4d38d24](https://github.com/workos/oagen-emitters/commit/4d38d249dcc7079e2a61d8faeabb681d6798618f))
+
+
+### Bug Fixes
+
+* **go:** stop SSO auth code leaking into request URL ([#83](https://github.com/workos/oagen-emitters/issues/83)) ([bc520e6](https://github.com/workos/oagen-emitters/commit/bc520e6a3d966abdf785262e5c49736b5e105b92))
+
 ## [0.7.5](https://github.com/workos/oagen-emitters/compare/v0.7.4...v0.7.5) (2026-05-03)
 
 

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { _ as nodeEmitter, a as rustExtractor, c as pythonExtractor, d as rubyEmitter, f as kotlinEmitter, g as pythonEmitter, h as phpEmitter, i as kotlinExtractor, l as rubyExtractor, m as goEmitter, n as elixirExtractor, o as goExtractor, p as dotnetEmitter, r as dotnetExtractor, s as phpExtractor, t as workosEmittersPlugin, u as nodeExtractor } from "./plugin-BoTAX4nl.mjs";
+import { _ as nodeEmitter, a as rustExtractor, c as pythonExtractor, d as rubyEmitter, f as kotlinEmitter, g as pythonEmitter, h as phpEmitter, i as kotlinExtractor, l as rubyExtractor, m as goEmitter, n as elixirExtractor, o as goExtractor, p as dotnetEmitter, r as dotnetExtractor, s as phpExtractor, t as workosEmittersPlugin, u as nodeExtractor } from "./plugin-bCMdV7KX.mjs";
 export { dotnetEmitter, dotnetExtractor, elixirExtractor, goEmitter, goExtractor, kotlinEmitter, kotlinExtractor, nodeEmitter, nodeExtractor, phpEmitter, phpExtractor, pythonEmitter, pythonExtractor, rubyEmitter, rubyExtractor, rustExtractor, workosEmittersPlugin };

package/dist/{plugin-BoTAX4nl.mjs → plugin-bCMdV7KX.mjs}

@@ -7633,6 +7633,17 @@ function deserializeField(ref, accessor, isRequired, walrusVar = "_v") {
 		case "union": {
 			const modelVariants = (ref.variants ?? []).filter((v) => v.kind === "model");
 			const uniqueModels = [...new Set(modelVariants.map((v) => v.name))];
+			if (ref.discriminator && ref.discriminator.mapping) {
+				const entries = Object.entries(ref.discriminator.mapping);
+				if (entries.length > 0) {
+					const dispatchMap = entries.map(([value, modelName]) => `"${value}": ${className$5(modelName)}`).join(", ");
+					const dataExpr = isRequired ? accessor : walrusVar;
+					const dataCast = `cast(Dict[str, Any], ${dataExpr})`;
+					const branch = `(_disc.from_dict(${dataCast}) if (_disc := ${`{${dispatchMap}}.get(${dataCast}.get("${ref.discriminator.property}"))`}) is not None else ${dataExpr})`;
+					if (isRequired) return branch;
+					return `(${branch}) if (${walrusVar} := ${accessor}) is not None else None`;
+				}
+			}
 			if (uniqueModels.length === 1) return deserializeField({
 				kind: "model",
 				name: uniqueModels[0]
@@ -10781,6 +10792,13 @@ function generateFromArrayValue(ref, accessor) {
 			return accessor;
 		case "nullable": return generateFromArrayValue(ref.inner, accessor);
 		case "union": {
+			if (ref.discriminator && ref.discriminator.mapping) {
+				const entries = Object.entries(ref.discriminator.mapping);
+				if (entries.length > 0) {
+					const arms = entries.map(([value, modelName]) => `'${value}' => ${className$4(modelName)}::fromArray(${accessor})`).join(", ");
+					return `match (${accessor}['${ref.discriminator.property}'] ?? null) { ${arms}, default => ${accessor} }`;
+				}
+			}
 			const resolved = resolveDegenerateUnion(ref);
 			if (resolved) return generateFromArrayValue(resolved, accessor);
 			return accessor;
@@ -12442,11 +12460,70 @@ function joinUnionVariants$2(_ref, variants) {
 	if (_ref.compositionKind === "allOf") return variants[0] ?? "interface{}";
 	const unique = [...new Set(variants)];
 	if (unique.length === 1) return unique[0];
+	if (_ref.discriminator && _ref.discriminator.mapping) {
+		const resolverName = unionResolverName(_ref);
+		if (resolverName) return resolverName;
+	}
 	return "interface{}";
 }
+/**
+* Pick a stable type name for a discriminated union's runtime resolver. Today
+* we emit no resolver struct, so we treat the union's first model variant as
+* the public type — matching the pre-discriminator behavior where Go just
+* referenced one variant directly. The Owner field stays typed, callers
+* can still inspect Type to detect the user variant (data loss on
+* non-overlapping fields like organization_id is documented in the SDK
+* compat report rather than fixed in the emitter — Go callers who need the
+* user-only fields can json.Unmarshal the raw payload manually).
+*/
+function unionResolverName(ref) {
+	for (const v of ref.variants) if (v.kind === "model") return `*${className$3(v.name)}`;
+	return null;
+}
 //#endregion
 //#region src/go/models.ts
 /**
+* Collect names of models that are referenced **only** as a named request body
+* model on an operation, with no other consumers (response types, pagination
+* item types, error types, or fields on other models).
+*
+* The Go emitter synthesizes a `{Service}{Method}Params` struct from those
+* request bodies (see `resources.ts:392`), and the method signature uses the
+* synthesized struct — never the named model. So emitting the named model in
+* `models.go` would leave callers with a duplicate, unused struct (the bug
+* surfaced in workos-go#544 with `CreateUserAPIKey` /
+* `UserManagementCreateAPIKeyParams`).
+*
+* Models in this set are skipped during model emission. Callers parameterize
+* the API surface through `*Params` exclusively, which is the sole consumer
+* of the spec's named request body schema.
+*/
+function collectRequestBodyOnlyModelNames$1(services, models) {
+	const requestBodyNames = /* @__PURE__ */ new Set();
+	const otherReferences = /* @__PURE__ */ new Set();
+	const collect = (ref, into) => {
+		if (!ref) return;
+		walkTypeRef(ref, { model: (r) => into.add(r.name) });
+	};
+	for (const service of services) for (const op of service.operations) {
+		if (op.requestBody?.kind === "model") requestBodyNames.add(op.requestBody.name);
+		collect(op.response, otherReferences);
+		if (op.pagination) collect(op.pagination.itemType, otherReferences);
+		for (const p of [
+			...op.pathParams,
+			...op.queryParams,
+			...op.headerParams,
+			...op.cookieParams ?? []
+		]) collect(p.type, otherReferences);
+		if (op.successResponses) for (const sr of op.successResponses) collect(sr.type, otherReferences);
+		for (const err of op.errors) if (err.type) collect(err.type, otherReferences);
+	}
+	for (const model of models) for (const field of model.fields) collect(field.type, otherReferences);
+	const result = /* @__PURE__ */ new Set();
+	for (const name of requestBodyNames) if (!otherReferences.has(name)) result.add(name);
+	return result;
+}
+/**
 * Generate Go struct definitions from IR Models.
 * All models go into a single models.go file for the flat package.
 */
@@ -12456,10 +12533,12 @@ function generateModels$3(models, ctx) {
 	const lines = [];
 	lines.push(`package ${ctx.namespace}`);
 	lines.push("");
+	const requestBodyOnly = collectRequestBodyOnlyModelNames$1(ctx.spec.services, models);
 	const modelHashMap = /* @__PURE__ */ new Map();
 	const hashGroups = /* @__PURE__ */ new Map();
 	for (const model of models) {
 		if (isListWrapperModel(model) || isListMetadataModel(model)) continue;
+		if (requestBodyOnly.has(model.name)) continue;
 		const hash = structuralHash$2(model);
 		modelHashMap.set(model.name, hash);
 		if (!hashGroups.has(hash)) hashGroups.set(hash, []);
@@ -12476,6 +12555,7 @@ function generateModels$3(models, ctx) {
 	const batchedAliases = /* @__PURE__ */ new Set();
 	for (const model of models) {
 		if (isListWrapperModel(model) || isListMetadataModel(model)) continue;
+		if (requestBodyOnly.has(model.name)) continue;
 		const structName = className$3(model.name);
 		const canonicalName = aliasOf.get(model.name);
 		if (canonicalName) {
@@ -13242,7 +13322,7 @@ function generateParamsStruct(mountName, method, op, plan, ctx, resolvedOp) {
 			emittedFields.add(goField);
 			const goType = !field.required ? makeOptional(mapTypeRef$3(field.type)) : mapTypeRef$3(field.type);
 			const jsonTag = field.required ? `json:"${field.name}"` : `json:"${field.name},omitempty"`;
-			const urlTag = op.queryParams.some((qp) => !hidden.has(qp.name) && fieldName$2(qp.name) === goField) ? ` url:"${field.name}${field.required ? "" : ",omitempty"}"` : "";
+			const urlTag = " url:\"-\"";
 			if (field.description) {
 				const fdLines = field.description.split("\n").filter((l) => l.trim());
 				lines.push(`\t// ${fieldDocComment(goField, fdLines[0])}`);
@@ -15094,9 +15174,8 @@ const discriminatedUnions$1 = /* @__PURE__ */ new Map();
 function joinUnionVariants$1(_ref, variants) {
 	if (_ref.compositionKind === "allOf") return variants[0] ?? "object";
 	const unique = [...new Set(variants)];
-	if (unique.length === 1) return unique[0];
 	if (_ref.discriminator && _ref.discriminator.mapping) {
-		const baseName = unique[0];
+		const baseName = _ref.variants.filter((v) => v.kind === "model").map((v) => v.kind === "model" ? v.name : "").filter(Boolean)[0] ?? unique[0];
 		discriminatedUnions$1.set(baseName, {
 			property: _ref.discriminator.property,
 			mapping: _ref.discriminator.mapping,
@@ -15104,6 +15183,7 @@ function joinUnionVariants$1(_ref, variants) {
 		});
 		return "object";
 	}
+	if (unique.length === 1) return unique[0];
 	if (unique.length >= 2 && unique.length <= 9) return `OneOf.OneOf<${unique.join(", ")}>`;
 	if (unique.length >= 10) console.warn(`[oagen:dotnet] Union with ${unique.length} variants exceeds OneOf<T0..T8> arity; falling back to object. Variants: ${unique.join(", ")}`);
 	return "object";
@@ -15119,6 +15199,7 @@ function generateModels$2(models, ctx, discCtx) {
 	if (models.length === 0) return [];
 	const enumConstByName = /* @__PURE__ */ new Map();
 	for (const e of ctx.spec.enums) if (e.values.length === 1) enumConstByName.set(e.name, String(e.values[0].value));
+	const requestBodyOnlyNames = collectRequestBodyOnlyModelNames(ctx.spec.services, models);
 	const files = [];
 	primeModelAliases(models);
 	const baseFieldLookup = /* @__PURE__ */ new Map();
@@ -15131,6 +15212,7 @@ function generateModels$2(models, ctx, discCtx) {
 	}
 	for (const model of models) {
 		if (isListWrapperModel(model) || isListMetadataModel(model)) continue;
+		if (requestBodyOnlyNames.has(model.name)) continue;
 		const csClassName = modelClassName(model.name);
 		if (isModelAlias(model.name)) continue;
 		const lines = [];
@@ -15209,6 +15291,8 @@ function generateModels$2(models, ctx, discCtx) {
 			}
 			const isRequiredEnum = field.required && isEnumRef(field.type) && constInit === null;
 			lines.push(...emitJsonPropertyAttributes(field.name, { isRequiredEnum }));
+			const discriminatedUnionConverter = discriminatedUnionConverterName(field.type);
+			if (discriminatedUnionConverter) lines.push(`        [Newtonsoft.Json.JsonConverter(typeof(${discriminatedUnionConverter}))]`);
 			const newMod = useNewModifier ? "new " : "";
 			lines.push(`        public ${newMod}${csType} ${csFieldName} { get; ${setterModifier}set; }${initializer}`);
 			if (isDictionaryOfObject(csType) && !field.deprecated) dictObjectFields.push({
@@ -15274,6 +15358,23 @@ function generateModels$2(models, ctx, discCtx) {
 	return files;
 }
 /**
+* Compute the name of the discriminator converter class for a field whose
+* type is a discriminated union, mirroring the keying used in
+* `joinUnionVariants` (first IR model variant name + "DiscriminatorConverter").
+* Returns null when the type isn't a discriminated union with a populated
+* mapping. Also walks through `nullable` so an optional discriminated field
+* still gets the converter applied.
+*/
+function discriminatedUnionConverterName(ref) {
+	const inner = ref.kind === "nullable" ? ref.inner : ref;
+	if (inner.kind !== "union") return null;
+	if (!inner.discriminator || !inner.discriminator.mapping) return null;
+	if (Object.keys(inner.discriminator.mapping).length === 0) return null;
+	const firstModel = inner.variants.find((v) => v.kind === "model");
+	if (!firstModel || firstModel.kind !== "model") return null;
+	return `${modelClassName(firstModel.name)}DiscriminatorConverter`;
+}
+/**
 * Whether the emitted C# type is `Dictionary<string, object>` or its
 * nullable variant — the usual shape of metadata / additional-properties
 * fields that get typed accessors.
@@ -15375,6 +15476,39 @@ function normalizeTypeForHash$1(ref, aliasOf) {
 function structuralHash$1(model, aliasOf = /* @__PURE__ */ new Map()) {
 	return model.fields.map((f) => `${f.name}:${JSON.stringify(normalizeTypeForHash$1(f.type, aliasOf))}:${f.required}`).sort().join("|");
 }
+/**
+* Names of models referenced **only** as a named operation request body —
+* i.e. never appearing in a response, an error, a paginated item type, or as
+* a field type on another model. The .NET wrapper generator emits a
+* per-operation `*Options` class containing the same fields, so the named
+* entity is never instantiated by callers and just clutters the SDK
+* (workos-dotnet#248: `CreateUserApiKey` vs `UserManagementCreateApiKeyOptions`).
+*/
+function collectRequestBodyOnlyModelNames(services, models) {
+	const requestBodyNames = /* @__PURE__ */ new Set();
+	const otherReferences = /* @__PURE__ */ new Set();
+	const collect = (ref, into) => {
+		if (!ref) return;
+		walkTypeRef(ref, { model: (r) => into.add(r.name) });
+	};
+	for (const service of services) for (const op of service.operations) {
+		if (op.requestBody?.kind === "model") requestBodyNames.add(op.requestBody.name);
+		collect(op.response, otherReferences);
+		if (op.pagination) collect(op.pagination.itemType, otherReferences);
+		for (const p of [
+			...op.pathParams,
+			...op.queryParams,
+			...op.headerParams,
+			...op.cookieParams ?? []
+		]) collect(p.type, otherReferences);
+		if (op.successResponses) for (const sr of op.successResponses) collect(sr.type, otherReferences);
+		for (const err of op.errors) if (err.type) collect(err.type, otherReferences);
+	}
+	for (const model of models) for (const field of model.fields) collect(field.type, otherReferences);
+	const result = /* @__PURE__ */ new Set();
+	for (const name of requestBodyNames) if (!otherReferences.has(name)) result.add(name);
+	return result;
+}
 //#endregion
 //#region src/dotnet/enums.ts
 /**
@@ -17100,7 +17234,7 @@ const dotnetEmitter = {
 			lines.push("            switch (discriminatorValue)");
 			lines.push("            {");
 			for (const [value, modelName] of Object.entries(disc.mapping)) {
-				const csName = modelClassName(modelName);
+				const csName = modelClassName(resolveModelName(modelName));
 				lines.push(`                case "${value}": return jObject.ToObject<${csName}>(serializer);`);
 			}
 			lines.push("                default: return jObject.ToObject<object>(serializer);");
@@ -17585,9 +17719,8 @@ const discriminatedUnions = /* @__PURE__ */ new Map();
 function joinUnionVariants(ref, variants) {
 	if (ref.compositionKind === "allOf") return variants[0] ?? "Any";
 	const unique = [...new Set(variants)];
-	if (unique.length === 1) return unique[0];
 	if (ref.discriminator && ref.discriminator.mapping) {
-		const baseName = unique[0];
+		const baseName = ref.variants.filter((v) => v.kind === "model").map((v) => v.kind === "model" ? v.name : "").filter(Boolean)[0] ?? unique[0];
 		discriminatedUnions.set(baseName, {
 			property: ref.discriminator.property,
 			mapping: ref.discriminator.mapping,
@@ -17595,6 +17728,7 @@ function joinUnionVariants(ref, variants) {
 		});
 		return baseName;
 	}
+	if (unique.length === 1) return unique[0];
 	return "Any";
 }
 /** Kotlin imports implied by a given type expression. Caller collects into a set. */
@@ -20095,8 +20229,15 @@ function deserializeExpression(accessor, ref, required, enumNames, modelNames) {
 	}
 	if (ref.kind === "enum" && enumNames.has(ref.name)) return accessor;
 	if (ref.kind === "union") {
-		const modelVariants = ref.variants.filter((v) => v.kind === "model" && modelNames.has(v.name));
-		if (modelVariants.length > 0 && modelVariants.length === ref.variants.length) return accessor;
+		if (ref.discriminator && ref.discriminator.mapping) {
+			const entries = Object.entries(ref.discriminator.mapping).filter(([, name]) => modelNames.has(name));
+			if (entries.length > 0) return `${accessor} ? ${`(case ${rubyHashAccessor(accessor, ref.discriminator.property)} ${entries.map(([value, modelName]) => {
+				const cls = `WorkOS::${className(modelName)}`;
+				return `when ${JSON.stringify(value)} then ${cls}.new(${accessor})`;
+			}).join(" ")} else ${accessor} end)`} : nil`;
+		}
+		const firstModelVariant = ref.variants.find((v) => v.kind === "model" && modelNames.has(v.name));
+		if (firstModelVariant && firstModelVariant.kind === "model") return `${accessor} ? ${`WorkOS::${className(firstModelVariant.name)}`}.new(${accessor}) : nil`;
 		return accessor;
 	}
 	if (ref.kind === "literal") return accessor;
@@ -22153,4 +22294,4 @@ const workosEmittersPlugin = {
 //#endregion
 export { nodeEmitter as _, rustExtractor as a, pythonExtractor as c, rubyEmitter as d, kotlinEmitter as f, pythonEmitter as g, phpEmitter as h, kotlinExtractor as i, rubyExtractor as l, goEmitter as m, elixirExtractor as n, goExtractor as o, dotnetEmitter as p, dotnetExtractor as r, phpExtractor as s, workosEmittersPlugin as t, nodeExtractor as u };
 
-//# sourceMappingURL=plugin-BoTAX4nl.mjs.map
+//# sourceMappingURL=plugin-bCMdV7KX.mjs.map