@workos/oagen 0.6.0 → 0.7.0

package/dist/cli/index.mjs

@@ -600,7 +600,7 @@ function findSchemaByName(pascalName, schemas) {
 	for (const [k, v] of Object.entries(schemas)) if (resolveSchemaName(k) === pascalName) return v;
 	return null;
 }
-/** Walk into a schema to find a field's sub-schema, resolving allOf. */
+/** Walk into a schema to find a field's sub-schema, resolving allOf and oneOf/anyOf. */
 function findNestedFieldSchema(fieldName, parentSchema, schemas) {
 	if (parentSchema.properties?.[fieldName]) return parentSchema.properties[fieldName];
 	if (parentSchema.allOf) for (const sub of parentSchema.allOf) {
@@ -612,6 +612,15 @@ function findNestedFieldSchema(fieldName, parentSchema, schemas) {
 		}
 		if (resolved.properties?.[fieldName]) return resolved.properties[fieldName];
 	}
+	for (const variant of [...parentSchema.oneOf ?? [], ...parentSchema.anyOf ?? []]) {
+		let resolved = variant;
+		if (variant.$ref) {
+			const segments = variant.$ref.split("/");
+			const refName = segments[segments.length - 1];
+			if (refName && schemas[refName]) resolved = schemas[refName];
+		}
+		if (resolved.properties?.[fieldName]) return resolved.properties[fieldName];
+	}
 	return null;
 }
 /** Extract a model (and nested models) from an inline field schema. */
@@ -777,6 +786,19 @@ function extractModel(name, schema, schemas) {
 		if (!fieldSchema) continue;
 		fields.push(buildFieldFromSchema(fieldName, fieldSchema, name, requiredSet));
 	}
+	if (fields.length === 0 && (schema.oneOf || schema.anyOf)) {
+		const variants = schema.oneOf ?? schema.anyOf ?? [];
+		const emptyRequired = /* @__PURE__ */ new Set();
+		const seenFieldNames = /* @__PURE__ */ new Set();
+		for (const variant of variants) {
+			if (!variant.properties) continue;
+			for (const [fieldName, fieldSchema] of Object.entries(variant.properties)) {
+				if (!fieldSchema || seenFieldNames.has(fieldName)) continue;
+				seenFieldNames.add(fieldName);
+				fields.push(buildFieldFromSchema(fieldName, fieldSchema, name, emptyRequired));
+			}
+		}
+	}
 	if (schema.additionalProperties && typeof schema.additionalProperties === "object" && schema.properties) {
 		if (Object.keys(schema.additionalProperties).length > 0) {
 			const valueType = schemaToTypeRef(schema.additionalProperties, "additionalProperties", name);
@@ -816,6 +838,18 @@ function extractAllOfModel(name, schema, schemas) {
 				});
 				if (f.required) requiredSet.add(f.name);
 			}
+		} else if (resolved.oneOf || resolved.anyOf) {
+			const variants = resolved.oneOf ?? resolved.anyOf ?? [];
+			const emptyRequired = /* @__PURE__ */ new Set();
+			const seenFieldNames = new Set(fields.map((f) => f.name));
+			for (const variant of variants) {
+				if (!variant.properties) continue;
+				for (const [fieldName, fieldSchema] of Object.entries(variant.properties)) {
+					if (!fieldSchema || seenFieldNames.has(fieldName)) continue;
+					seenFieldNames.add(fieldName);
+					fields.push(buildFieldFromSchema(fieldName, fieldSchema, name, emptyRequired));
+				}
+			}
 		} else {
 			if (resolved.required) for (const r of resolved.required) requiredSet.add(r);
 			if (resolved.properties) {
@@ -1672,6 +1706,94 @@ function inferDeeperContext(path) {
 	if (nonParams.length >= 3) return toPascalCase(nonParams.slice(1, -1).join("_"));
 	return null;
 }
+/**
+* Extract mutually-exclusive parameter groups from the `x-mutually-exclusive-parameter-groups`
+* operation extension. Cross-references grouped parameter names against the already-extracted
+* IR parameter arrays so emitters get object-identity references.
+*/
+function extractParameterGroups(op, allIRParams, operationContext) {
+	const raw = op["x-mutually-exclusive-parameter-groups"];
+	if (!raw || typeof raw !== "object") return void 0;
+	const paramByName = /* @__PURE__ */ new Map();
+	for (const p of allIRParams) paramByName.set(p.name, p);
+	const groups = [];
+	for (const [groupName, groupDef] of Object.entries(raw)) {
+		if (!groupDef || typeof groupDef !== "object") throw new Error(`Malformed x-mutually-exclusive-parameter-groups.${groupName} in ${operationContext}: expected an object with "optional" and "variants".`);
+		if (typeof groupDef.optional !== "boolean") throw new Error(`Malformed x-mutually-exclusive-parameter-groups.${groupName}.optional in ${operationContext}: expected a boolean.`);
+		if (!groupDef.variants || typeof groupDef.variants !== "object") throw new Error(`Malformed x-mutually-exclusive-parameter-groups.${groupName}.variants in ${operationContext}: expected an object mapping variant names to parameter name arrays.`);
+		if (Object.keys(groupDef.variants).length === 0) throw new Error(`Malformed x-mutually-exclusive-parameter-groups.${groupName} in ${operationContext}: group has zero variants.`);
+		const variants = Object.entries(groupDef.variants).map(([variantName, paramNames]) => {
+			if (!Array.isArray(paramNames) || paramNames.length === 0) throw new Error(`Malformed x-mutually-exclusive-parameter-groups.${groupName}.variants.${variantName} in ${operationContext}: expected a non-empty array of parameter names.`);
+			return {
+				name: variantName,
+				parameters: paramNames.map((pName) => {
+					const irParam = paramByName.get(pName);
+					if (!irParam) throw new Error(`x-mutually-exclusive-parameter-groups.${groupName}.variants.${variantName} references parameter "${pName}" which does not exist in the operation's parameters[] (${operationContext}).`);
+					return irParam;
+				})
+			};
+		});
+		groups.push({
+			name: groupName,
+			optional: groupDef.optional,
+			variants
+		});
+	}
+	return groups.length > 0 ? groups : void 0;
+}
+/**
+* Extract mutually-exclusive body parameter groups from the
+* `x-mutually-exclusive-body-groups` operation extension. Unlike query
+* parameter groups (whose parameters live in operation.queryParams), body
+* group parameters are synthetic — built from the oneOf variant schemas in
+* the request body. Emitters use the group's presence to generate sum-type
+* interfaces and custom JSON marshalling instead of flat optional fields.
+*/
+function extractBodyParameterGroups(op, operationContext) {
+	const raw = op["x-mutually-exclusive-body-groups"];
+	if (!raw || typeof raw !== "object") return void 0;
+	const bodySchema = op.requestBody?.content?.["application/json"]?.schema;
+	const variantFieldSchemas = /* @__PURE__ */ new Map();
+	if (bodySchema) {
+		for (const sub of bodySchema.allOf ?? []) for (const variant of sub.oneOf ?? []) if (variant.properties) {
+			for (const [name, fieldSchema] of Object.entries(variant.properties)) if (fieldSchema) variantFieldSchemas.set(name, fieldSchema);
+		}
+		for (const variant of bodySchema.oneOf ?? []) if (variant.properties) {
+			for (const [name, fieldSchema] of Object.entries(variant.properties)) if (fieldSchema) variantFieldSchemas.set(name, fieldSchema);
+		}
+	}
+	const groups = [];
+	for (const [groupName, groupDef] of Object.entries(raw)) {
+		if (!groupDef || typeof groupDef !== "object") continue;
+		if (typeof groupDef.optional !== "boolean") continue;
+		if (!groupDef.variants || typeof groupDef.variants !== "object") continue;
+		if (Object.keys(groupDef.variants).length === 0) continue;
+		const variants = Object.entries(groupDef.variants).map(([variantName, paramNames]) => {
+			if (!Array.isArray(paramNames) || paramNames.length === 0) throw new Error(`Malformed x-mutually-exclusive-body-groups.${groupName}.variants.${variantName} in ${operationContext}: expected a non-empty array of parameter names.`);
+			return {
+				name: variantName,
+				parameters: paramNames.map((pName) => {
+					const fieldSchema = variantFieldSchemas.get(pName);
+					return {
+						name: pName,
+						type: fieldSchema ? schemaToTypeRef(fieldSchema, toPascalCase(pName)) : {
+							kind: "primitive",
+							type: "string"
+						},
+						required: false,
+						description: fieldSchema?.description
+					};
+				})
+			};
+		});
+		groups.push({
+			name: groupName,
+			optional: groupDef.optional,
+			variants
+		});
+	}
+	return groups.length > 0 ? groups : void 0;
+}
 function buildOperation(method, path, op, pathLevelParams, operationIdTransform, serviceName) {
 	const allParams = [...pathLevelParams, ...op.parameters ?? []];
 	const hasIdempotencyHeader = allParams.some((p) => p.in === "header" && p.name.toLowerCase() === "idempotency-key");
@@ -1697,6 +1819,16 @@ function buildOperation(method, path, op, pathLevelParams, operationIdTransform,
 		};
 	} else if (paginationFromParams) pagination = paginationFromParams;
 	const security = extractOperationSecurity(op.security);
+	const allIRParams = [
+		...pathParams,
+		...queryParams,
+		...headerParams,
+		...cookieParams
+	];
+	const opLabel = op.operationId ?? `${method.toUpperCase()} ${path}`;
+	const queryParamGroups = extractParameterGroups(op, allIRParams, opLabel);
+	const bodyParamGroups = extractBodyParameterGroups(op, opLabel);
+	const parameterGroups = queryParamGroups || bodyParamGroups ? [...queryParamGroups ?? [], ...bodyParamGroups ?? []] : void 0;
 	return {
 		operation: {
 			name: inferOperationName(method, path, op.operationId, operationIdTransform),
@@ -1716,7 +1848,8 @@ function buildOperation(method, path, op, pathLevelParams, operationIdTransform,
 			injectIdempotencyKey: hasIdempotencyHeader,
 			deprecated: op.deprecated || void 0,
 			async: op["x-oagen-async"],
-			security
+			security,
+			parameterGroups
 		},
 		inlineModels
 	};
@@ -2971,6 +3104,7 @@ const nodeMergeAdapter = {
 		const newText = newMembers.map((m) => m.text).join("\n");
 		for (const match of newText.matchAll(/this\.(\w+)/g)) {
 			const propName = match[1];
+			if (propName === "workos") continue;
 			if (propName && !existingMemberKeys.has(propName)) return true;
 		}
 		return false;
@@ -3627,6 +3761,40 @@ function buildIgnoredSymbolNames(docstrings, regions) {
 	for (const [name, info] of docstrings) if (regions.some((r) => info.declStartIndex >= r.startIndex && info.declStartIndex <= r.endIndex)) ignored.add(name);
 	return ignored;
 }
+function clampIndex(value, contentLength) {
+	if (!Number.isFinite(value)) return 0;
+	if (value < 0) return 0;
+	if (value > contentLength) return contentLength;
+	return value;
+}
+/**
+* Resolve the declaration line start for insertion using the current content,
+* instead of relying on parser column arithmetic. This avoids misplaced inserts
+* when parser columns/offsets drift.
+*/
+function declarationLineStart(content, declStartIndex) {
+	const idx = clampIndex(declStartIndex, content.length);
+	const prevNewline = content.lastIndexOf("\n", Math.max(0, idx - 1));
+	return prevNewline === -1 ? 0 : prevNewline + 1;
+}
+/**
+* Resolve a docstring range by searching for the nearest matching text before
+* the declaration start. Falls back to parser-provided offsets when search fails.
+*/
+function resolveDocRange(content, docText, declStartIndex, fallbackStart, fallbackEnd) {
+	const safeDecl = clampIndex(declStartIndex, content.length);
+	const safeFallbackStart = clampIndex(fallbackStart, content.length);
+	const safeFallbackEnd = clampIndex(fallbackEnd, content.length);
+	const found = content.lastIndexOf(docText, safeDecl);
+	if (found !== -1) return {
+		start: found,
+		end: found + docText.length
+	};
+	return {
+		start: safeFallbackStart,
+		end: safeFallbackEnd
+	};
+}
 /**
 * Check if a tree-sitter grammar is configured for the given language.
 */
@@ -3675,15 +3843,17 @@ async function extractClassEndLines(source, language) {
 		if (source[body ? body.endIndex - 1 : node.endIndex - 1] === "}") map.set(name, { bodyEndLine: endRow });
 		else map.set(name, { bodyEndLine: endRow + 1 });
 	}
-	for (const child of tree.rootNode.children) {
-		if (child.type === "class_definition" || child.type === "class_declaration") processClassNode(child);
-		if (child.type === "decorated_definition") {
-			for (const inner of child.namedChildren) if (inner.type === "class_definition") processClassNode(inner);
+	function walk(node) {
+		if (node.type === "class" || node.type === "class_definition" || node.type === "class_declaration") processClassNode(node);
+		if (node.type === "decorated_definition") {
+			for (const inner of node.namedChildren) if (inner.type === "class_definition") processClassNode(inner);
 		}
-		if (child.type === "export_statement") {
-			for (const inner of child.namedChildren) if (inner.type === "class_declaration") processClassNode(inner);
+		if (node.type === "export_statement") {
+			for (const inner of node.namedChildren) if (inner.type === "class_declaration") processClassNode(inner);
 		}
+		for (const child of node.namedChildren) walk(child);
 	}
+	for (const child of tree.rootNode.children) walk(child);
 	return map;
 }
 /**
@@ -3903,15 +4073,16 @@ async function mergeIntoExisting(existingContent, generatedContent, language, he
 			if (genDoc) if (existInfo.docstring) {
 				if (!existInfo.docstring.text.includes("@oagen-ignore") && existInfo.docstring.text !== genDoc.text) {
 					const newText = preserveDeprecatedTags(existInfo.docstring.text, genDoc.text);
+					const range = resolveDocRange(result, existInfo.docstring.text, existInfo.declStartIndex, existInfo.docstring.startIndex, existInfo.docstring.endIndex);
 					edits.push({
-						start: existInfo.docstring.startIndex,
-						end: existInfo.docstring.endIndex,
+						start: range.start,
+						end: range.end,
 						newText
 					});
 					docstringUpdates++;
 				}
 			} else {
-				const lineStart = existInfo.declStartIndex - existInfo.declColumn;
+				const lineStart = declarationLineStart(result, existInfo.declStartIndex);
 				const indent = " ".repeat(existInfo.declColumn);
 				edits.push({
 					start: lineStart,
@@ -3929,15 +4100,16 @@ async function mergeIntoExisting(existingContent, generatedContent, language, he
 				if (existMember.docstring) {
 					if (!existMember.docstring.text.includes("@oagen-ignore") && existMember.docstring.text !== genMember.docstring.text) {
 						const newText = preserveDeprecatedTags(existMember.docstring.text, genMember.docstring.text);
+						const range = resolveDocRange(result, existMember.docstring.text, existMember.declStartIndex, existMember.docstring.startIndex, existMember.docstring.endIndex);
 						edits.push({
-							start: existMember.docstring.startIndex,
-							end: existMember.docstring.endIndex,
+							start: range.start,
+							end: range.end,
 							newText
 						});
 						docstringUpdates++;
 					}
 				} else {
-					const lineStart = existMember.declStartIndex - existMember.declColumn;
+					const lineStart = declarationLineStart(result, existMember.declStartIndex);
 					const indent = " ".repeat(existMember.declColumn);
 					edits.push({
 						start: lineStart,
@@ -3982,15 +4154,16 @@ async function mergeIntoExisting(existingContent, generatedContent, language, he
 					if (existMember.docstring.text.includes("@oagen-ignore")) continue;
 					if (existMember.docstring.text !== genMember.docstring.text) {
 						const newText = preserveDeprecatedTags(existMember.docstring.text, genMember.docstring.text);
+						const range = resolveDocRange(result, existMember.docstring.text, existMember.declStartIndex, existMember.docstring.startIndex, existMember.docstring.endIndex);
 						edits.push({
-							start: existMember.docstring.startIndex,
-							end: existMember.docstring.endIndex,
+							start: range.start,
+							end: range.end,
 							newText
 						});
 						docstringUpdates++;
 					}
 				} else {
-					const lineStart = existMember.declStartIndex - existMember.declColumn;
+					const lineStart = declarationLineStart(result, existMember.declStartIndex);
 					const indent = " ".repeat(existMember.declColumn);
 					edits.push({
 						start: lineStart,
@@ -4163,7 +4336,7 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 		});
 	}
 	if (blocks.length === 0) return generatedContent;
-	const result = [...generatedLines];
+	const result = stripIgnoreRegions(generatedLines);
 	spliceExtraImports(existingLines, result);
 	const classEndLines = await extractClassEndLines(result.join("\n"), language);
 	const blocksByClass = /* @__PURE__ */ new Map();
@@ -4230,10 +4403,33 @@ async function overwriteWithPreservedRegions(existingContent, generatedContent,
 	for (const ins of insertions) result.splice(ins.line, 0, ...ins.content);
 	return result.join("\n");
 }
+/**
+* Remove every `@oagen-ignore-start`..`@oagen-ignore-end` region from the
+* supplied lines, collapsing stretches of blank lines that get left behind.
+* Used to drop generator-emitted seed blocks before splicing the on-disk
+* versions back in — otherwise every regen doubles up.
+*/
+function stripIgnoreRegions(lines) {
+	const out = [];
+	let skipping = false;
+	for (const line of lines) {
+		if (!skipping && line.includes("@oagen-ignore-start")) {
+			skipping = true;
+			while (out.length > 0 && out[out.length - 1].trim() === "") out.pop();
+			continue;
+		}
+		if (skipping) {
+			if (line.includes("@oagen-ignore-end")) skipping = false;
+			continue;
+		}
+		out.push(line);
+	}
+	return out;
+}
 /** Scan backwards from `lineIdx` to find the nearest class declaration name. */
 function findContainingClass(lines, lineIdx) {
 	for (let j = lineIdx - 1; j >= 0; j--) {
-		const m = lines[j].match(/^(?:export\s+)?class\s+(\w+)/);
+		const m = lines[j].match(/^\s*(?:export\s+)?class\s+(\w+)/);
 		if (m) return m[1];
 	}
 	return "";
@@ -4243,7 +4439,7 @@ function findContainingClass(lines, lineIdx) {
 * by scanning backwards from `beforeLine`.
 */
 function findClassDeclarationStart(lines, className, beforeLine) {
-	const classPattern = new RegExp(`^(?:export\\s+)?class\\s+${className}\\b`);
+	const classPattern = new RegExp(`^\\s*(?:export\\s+)?class\\s+${className}\\b`);
 	for (let i = beforeLine - 1; i >= 0; i--) {
 		if (!classPattern.test(lines[i])) continue;
 		let start = i;
@@ -4712,7 +4908,8 @@ async function resolveFileToDirectoryConflicts(files, targetDir) {
 	};
 }
 async function integrateGeneratedFiles(opts) {
-	const { files: resolved, removals } = await resolveFileToDirectoryConflicts(await treeShakeFiles(mapFilesForTargetIntegration(opts.files, opts.language), opts.language), opts.targetDir);
+	const mapped = mapFilesForTargetIntegration(opts.files, opts.language);
+	const { files: resolved, removals } = await resolveFileToDirectoryConflicts(await treeShakeFiles(mapped, opts.language), opts.targetDir);
 	const result = await writeFiles(resolved, opts.targetDir, {
 		language: opts.language,
 		header: opts.header
@@ -4722,7 +4919,7 @@ async function integrateGeneratedFiles(opts) {
 	} catch {}
 	return {
 		...result,
-		emittedPaths: resolved.map((f) => f.path)
+		emittedPaths: mapped.map((f) => f.path)
 	};
 }
 //#endregion
@@ -4746,6 +4943,7 @@ async function formatTargetFiles(emitter, targetDir, filePaths) {
 	if (!formatCmd) return;
 	const absolutePaths = filePaths.map((f) => path$1.resolve(targetDir, f));
 	const batchSize = formatCmd.batchSize ?? 100;
+	process.stderr.write(`[oagen] formatting ${absolutePaths.length} file(s) with ${formatCmd.cmd} (batch ${batchSize})\n`);
 	for (let i = 0; i < absolutePaths.length; i += batchSize) {
 		const batch = absolutePaths.slice(i, i + batchSize);
 		try {
@@ -4754,7 +4952,10 @@ async function formatTargetFiles(emitter, targetDir, filePaths) {
 				maxBuffer: 10 * 1024 * 1024,
 				timeout: 12e4
 			});
-		} catch {}
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			process.stderr.write(`[oagen] formatter batch failed: ${msg}\n`);
+		}
 	}
 }
 //#endregion