@workos/oagen 0.22.6 → 0.22.7

package/dist/cli/index.mjs

@@ -2694,6 +2694,7 @@ async function parseSpec(specPath, options) {
 	const fieldInlineModels = extractInlineModelsFromSchemas(spec.components?.schemas);
 	clearSchemaNameTransform();
 	const finalModels = collapseJsonSuffixModels(mergeFieldInlineModels(responseNormalizedModels, fieldInlineModels), services);
+	applyFieldHints(finalModels, options?.fieldHints);
 	collectInlineEnumsFromModels(finalModels, enums);
 	collectInlineEnumsFromOperations(services, enums);
 	const auth = extractAuthSchemes(spec.components?.securitySchemes);
@@ -2716,6 +2717,22 @@ async function parseSpec(specPath, options) {
 	validateModelRefs(result);
 	return result;
 }
+/**
+* Apply `fieldHints` onto the built models, setting `Field.domainName` for each
+* matching (model name, wire field name) pair. Serialization still uses
+* `Field.name`; only the domain-facing identifier changes.
+*/
+function applyFieldHints(models, fieldHints) {
+	if (!fieldHints) return;
+	for (const model of models) {
+		const hints = fieldHints[model.name];
+		if (!hints) continue;
+		for (const field of model.fields) {
+			const domainName = hints[field.name];
+			if (domainName) field.domainName = domainName;
+		}
+	}
+}
 /** Extract authentication schemes from OpenAPI securitySchemes. */
 function extractAuthSchemes(securitySchemes) {
 	if (!securitySchemes) return void 0;
@@ -5272,6 +5289,60 @@ function collectTsImports(lines) {
 	return out;
 }
 /**
+* Remove the given symbols from generated `import type` bindings, in place.
+*
+* Called when an existing *value* import for the same symbol is being spliced
+* back into the file. A value import satisfies both runtime and type uses, so
+* leaving the generated `import type { X }` would re-declare `X` (TS2300
+* duplicate identifier). Callers guarantee every symbol here is absent from
+* generated *value* imports, so each occurrence is type-only and safe to drop.
+*
+* Handles whole-line `import type { … }` and inline `import { …, type X }`,
+* single- or multi-line. A statement whose bindings all get stripped is
+* removed entirely.
+*/
+function dropGeneratedTypeOnlyBindings(resultLines, symbols) {
+	if (symbols.size === 0) return;
+	const out = [];
+	for (let i = 0; i < resultLines.length; i++) {
+		const line = resultLines[i];
+		const trimmed = line.trim();
+		if (!/^import\b/.test(trimmed) || !trimmed.includes("{")) {
+			out.push(line);
+			continue;
+		}
+		const span = [line];
+		while (!span.join(" ").includes("}") && i + 1 < resultLines.length) {
+			i++;
+			span.push(resultLines[i]);
+		}
+		const m = span.join(" ").replace(/\s+/g, " ").trim().replace(/;\s*$/, "").match(/^import\s+(type\s+)?(?:(\w+)\s*,\s*)?\{\s*([^}]*)\s*\}\s+from\s+(['"][^'"]+['"])$/);
+		if (!m) {
+			for (const s of span) out.push(s);
+			continue;
+		}
+		const isTypeOnly = !!m[1];
+		const defaultName = m[2];
+		const items = m[3].split(",").map((s) => s.trim()).filter(Boolean);
+		const modQuoted = m[4];
+		const kept = items.filter((raw) => {
+			const isTypeBinding = isTypeOnly || raw.startsWith("type ");
+			const bare = raw.replace(/^type\s+/, "");
+			return !(isTypeBinding && symbols.has(bare));
+		});
+		if (kept.length === items.length) {
+			for (const s of span) out.push(s);
+			continue;
+		}
+		if (kept.length === 0 && !defaultName) continue;
+		const lead = line.match(/^(\s*)/)?.[1] ?? "";
+		const prefix = isTypeOnly ? "import type " : "import ";
+		const defaultPart = defaultName ? `${defaultName}, ` : "";
+		out.push(`${lead}${prefix}${defaultPart}{ ${kept.join(", ")} } from ${modQuoted};`);
+	}
+	resultLines.splice(0, resultLines.length, ...out);
+}
+/**
 * Add imports from the existing file that are absent from the generated
 * result. Handles:
 *
@@ -5393,28 +5464,49 @@ function spliceExtraImports(existingLines, resultLines) {
 	const existingTs = collectTsImports(existingOutsideIgnore);
 	const generatedTs = collectTsImports(resultLines);
 	const extraTsLines = [];
+	const allGeneratedTsIds = /* @__PURE__ */ new Set();
+	const generatedValueIds = /* @__PURE__ */ new Set();
+	for (const ids of generatedTs.named.values()) for (const id of ids) {
+		allGeneratedTsIds.add(id);
+		generatedValueIds.add(id);
+	}
+	for (const ids of generatedTs.typeOnly.values()) for (const id of ids) allGeneratedTsIds.add(id);
+	for (const name of generatedTs.defaults.values()) {
+		allGeneratedTsIds.add(name);
+		generatedValueIds.add(name);
+	}
+	for (const name of generatedTs.namespaces.values()) {
+		allGeneratedTsIds.add(name);
+		generatedValueIds.add(name);
+	}
+	const reclaimedValueIds = /* @__PURE__ */ new Set();
+	const generatedHasValue = (id) => generatedValueIds.has(id);
+	const generatedHasTypeOnly = (id) => allGeneratedTsIds.has(id) && !generatedValueIds.has(id);
 	for (const mod of existingTs.sideEffects) if (!generatedTs.sideEffects.has(mod)) extraTsLines.push(`import '${mod}';`);
 	for (const [mod, name] of existingTs.defaults) {
 		if (generatedTs.defaults.has(mod)) continue;
 		if (!identifierUsed(ignoreRegionText, name)) continue;
+		if (generatedHasValue(name)) continue;
+		if (generatedHasTypeOnly(name)) reclaimedValueIds.add(name);
 		extraTsLines.push(`import ${name} from '${mod}';`);
 	}
 	for (const [mod, name] of existingTs.namespaces) {
 		if (!identifierUsed(ignoreRegionText, name)) continue;
-		if (!generatedTs.namespaces.has(mod)) extraTsLines.push(`import * as ${name} from '${mod}';`);
+		if (generatedHasValue(name)) continue;
+		if (generatedTs.namespaces.has(mod)) continue;
+		if (generatedHasTypeOnly(name)) reclaimedValueIds.add(name);
+		extraTsLines.push(`import * as ${name} from '${mod}';`);
 	}
 	for (const [mod, existIds] of existingTs.named) {
-		const genIds = generatedTs.named.get(mod) ?? /* @__PURE__ */ new Set();
-		const genTypeIds = generatedTs.typeOnly.get(mod) ?? /* @__PURE__ */ new Set();
-		const extra = [...existIds].filter((id) => !genIds.has(id) && !genTypeIds.has(id) && identifierUsed(ignoreRegionText, id));
+		const extra = [...existIds].filter((id) => !generatedHasValue(id) && identifierUsed(ignoreRegionText, id));
+		for (const id of extra) if (generatedHasTypeOnly(id)) reclaimedValueIds.add(id);
 		if (extra.length > 0) extraTsLines.push(`import { ${extra.join(", ")} } from '${mod}';`);
 	}
 	for (const [mod, existIds] of existingTs.typeOnly) {
-		const genIds = generatedTs.typeOnly.get(mod) ?? /* @__PURE__ */ new Set();
-		const genNamedIds = generatedTs.named.get(mod) ?? /* @__PURE__ */ new Set();
-		const extra = [...existIds].filter((id) => !genIds.has(id) && !genNamedIds.has(id) && identifierUsed(ignoreRegionText, id));
+		const extra = [...existIds].filter((id) => !allGeneratedTsIds.has(id) && identifierUsed(ignoreRegionText, id));
 		if (extra.length > 0) extraTsLines.push(`import type { ${extra.join(", ")} } from '${mod}';`);
 	}
+	dropGeneratedTypeOnlyBindings(resultLines, reclaimedValueIds);
 	const isPhpUseImport = (l) => /^use\s+[\w\\]+\\[\w\\]*(\s+as\s+\w+)?\s*;?$/.test(l);
 	const existingPhpUse = new Set(existingOutsideIgnore.filter(isPhpUseImport).map((l) => l.trim()));
 	const generatedPhpUse = new Set(resultLines.filter(isPhpUseImport).map((l) => l.trim()));
@@ -5458,7 +5550,31 @@ function spliceExtraImports(existingLines, resultLines) {
 			if ((resultLines[i].match(/[)}]/g) ?? []).length > 0) break;
 		}
 	}
-	if (lastImportIdx >= 0) resultLines.splice(lastImportIdx + 1, 0, ...allExtra);
+	if (lastImportIdx >= 0) {
+		resultLines.splice(lastImportIdx + 1, 0, ...allExtra);
+		return;
+	}
+	let insertAt = 0;
+	let inBlockComment = false;
+	for (let i = 0; i < resultLines.length; i++) {
+		const t = resultLines[i].trim();
+		if (inBlockComment) {
+			insertAt = i + 1;
+			if (t.includes("*/")) inBlockComment = false;
+			continue;
+		}
+		if (t.startsWith("//")) {
+			insertAt = i + 1;
+			continue;
+		}
+		if (t.startsWith("/*")) {
+			insertAt = i + 1;
+			inBlockComment = !t.includes("*/");
+			continue;
+		}
+		break;
+	}
+	resultLines.splice(insertAt, 0, ...allExtra);
 }
 //#endregion
 //#region src/ir/operation-hints.ts
@@ -6832,7 +6948,8 @@ async function generateCommand(opts) {
 	let ir = await parseSpec(opts.spec, {
 		operationIdTransform: opts.operationIdTransform,
 		schemaNameTransform: opts.schemaNameTransform,
-		transformSpec: opts.transformSpec
+		transformSpec: opts.transformSpec,
+		fieldHints: opts.fieldHints
 	});
 	if (opts.docUrl) ir = expandDocUrls(ir, opts.docUrl);
 	const emitter = getEmitter(opts.lang);
@@ -9802,6 +9919,7 @@ let configDocUrl;
 let configOperationHints;
 let configMountRules;
 let configModelHints;
+let configFieldHints;
 let configEmitterOptions;
 let configCompat;
 try {
@@ -9816,6 +9934,7 @@ try {
 		configOperationHints = config.operationHints;
 		configMountRules = config.mountRules;
 		configModelHints = config.modelHints;
+		configFieldHints = config.fieldHints;
 		configEmitterOptions = config.emitterOptions;
 		configCompat = config.compat;
 	}
@@ -9851,6 +9970,7 @@ program.command("generate").description("Run a registered emitter against an Ope
 		operationHints: configOperationHints,
 		mountRules: configMountRules,
 		modelHints: configModelHints,
+		fieldHints: configFieldHints,
 		emitterOptions: configEmitterOptions?.[opts.lang]
 	}).catch(handleError);
 });