@workos/oagen-emitters 0.3.0 → 0.5.0

package/src/dotnet/type-map.ts

@@ -0,0 +1,228 @@
+import type { TypeRef, PrimitiveType, UnionType } from '@workos/oagen';
+import { mapTypeRef as irMapTypeRef } from '@workos/oagen';
+import { className, modelClassName } from './naming.js';
+
+/** Known C# value types that need `?` for nullable. */
+const VALUE_TYPES = new Set(['int', 'long', 'double', 'bool', 'float', 'decimal', 'byte', 'short', 'DateTimeOffset']);
+
+/**
+ * Module-level alias map for structurally-identical enums. Populated by
+ * `setEnumAliases` from the current spec's enum list; consulted by
+ * `mapTypeRef` so that every reference to a duplicate enum resolves to the
+ * canonical name. C# has no first-class type alias for enums, so dedup must
+ * happen at reference-rewrite time rather than via a runtime alias.
+ */
+const enumAliases = new Map<string, string>();
+
+/**
+ * Names of enums that resolve to a single wire value and should therefore be
+ * mapped to C# `string` at reference sites (the owning property emits a
+ * const initializer). Populated by `setSingleValueEnumNames`.
+ */
+const singleValueEnumNames = new Set<string>();
+
+/**
+ * Module-level alias map for structurally-identical models. Populated by
+ * `setModelAliases` from model deduplication; consulted by `mapTypeRef` so
+ * that every reference to a duplicate model resolves to the canonical name.
+ */
+const modelAliases = new Map<string, string>();
+
+/** Replace the current enum-alias map. Safe to call more than once. */
+export function setEnumAliases(aliases: Map<string, string>): void {
+  enumAliases.clear();
+  for (const [k, v] of aliases) enumAliases.set(k, v);
+}
+
+/** Replace the current model-alias map. Safe to call more than once. */
+export function setModelAliases(aliases: Map<string, string>): void {
+  modelAliases.clear();
+  for (const [k, v] of aliases) modelAliases.set(k, v);
+}
+
+/** Check if a model name is an alias (i.e., structurally identical to another model). */
+export function isModelAlias(name: string): boolean {
+  return modelAliases.has(name);
+}
+
+/** Resolve a model name to its canonical form (identity if not an alias). */
+export function resolveModelName(name: string): string {
+  return modelAliases.get(name) ?? name;
+}
+
+/** Replace the set of enum names that are single-value discriminator stand-ins. */
+export function setSingleValueEnumNames(names: Iterable<string>): void {
+  singleValueEnumNames.clear();
+  for (const n of names) singleValueEnumNames.add(n);
+}
+
+/** Resolve an enum reference name to its canonical form. */
+export function resolveEnumTypeName(name: string): string {
+  return enumAliases.get(name) ?? name;
+}
+
+/**
+ * Map an IR TypeRef to a C# type string.
+ */
+export function mapTypeRef(ref: TypeRef): string {
+  return irMapTypeRef<string>(ref, {
+    primitive: mapPrimitive,
+    array: (_ref, items) => `List<${items}>`,
+    model: (r) => modelClassName(modelAliases.get(r.name) ?? r.name),
+    enum: (r) => {
+      // Single-value enums (discriminator consts in disguise) map to `string`
+      // so the caller can't misuse a public one-member enum type. The
+      // owning property emits a const initializer separately.
+      if ((r.values?.length ?? 0) === 1) return 'string';
+      if (singleValueEnumNames.has(r.name)) return 'string';
+      return className(resolveEnumTypeName(r.name));
+    },
+    union: (_r, variants) => joinUnionVariants(_r, variants),
+    nullable: (_ref, inner) => {
+      // With <Nullable>enable</Nullable>, all nullable types need `?`
+      if (inner.endsWith('?')) return inner; // already nullable (e.g., nested nullable)
+      return `${inner}?`;
+    },
+    literal: (r) => {
+      if (r.value === null) return 'object';
+      if (typeof r.value === 'string') return 'string';
+      if (typeof r.value === 'number') return Number.isInteger(r.value) ? 'int' : 'double';
+      if (typeof r.value === 'boolean') return 'bool';
+      return 'object';
+    },
+    map: (_ref, value) => `Dictionary<string, ${value}>`,
+  });
+}
+
+/**
+ * Map an IR TypeRef to a C# type string, making optional fields nullable.
+ * For value types, appends `?`. For reference types, returns as-is.
+ */
+export function mapTypeRefOptional(ref: TypeRef): string {
+  const baseType = mapTypeRef(ref);
+  if (isValueType(baseType)) return `${baseType}?`;
+  return baseType;
+}
+
+/**
+ * Check if a C# type is a value type (needs ? for nullable).
+ */
+export function isValueType(csType: string): boolean {
+  // Strip trailing ? if present
+  const bare = csType.endsWith('?') ? csType.slice(0, -1) : csType;
+  if (VALUE_TYPES.has(bare)) return true;
+  // Enums are value types, but we can't detect them purely from the type string.
+  // The caller should handle enum nullability explicitly when needed.
+  return false;
+}
+
+/**
+ * Check if an IR TypeRef maps to a C# value type.
+ */
+export function isValueTypeRef(ref: TypeRef): boolean {
+  if (ref.kind === 'enum') return true;
+  if (ref.kind === 'primitive') {
+    // DateTimeOffset is a value type (struct)
+    if (ref.format === 'date-time') return true;
+    switch (ref.type) {
+      case 'integer':
+      case 'number':
+      case 'boolean':
+        return true;
+      default:
+        return false;
+    }
+  }
+  return false;
+}
+
+/**
+ * Whether a TypeRef directly names an enum (no nullable wrapper).
+ * Used to detect required enum request fields that must not silently serialize
+ * their default Unknown sentinel.
+ */
+export function isEnumRef(ref: TypeRef): boolean {
+  return ref.kind === 'enum';
+}
+
+/**
+ * Emit JSON attributes for a request-side property. Property name mapping is
+ * handled by a global SnakeCaseLower / SnakeCaseNamingStrategy configuration
+ * on both serializers, so per-property name attributes are not emitted.
+ *
+ * When `isRequiredEnum` is true, configure both serializers to skip the field
+ * when its value equals the enum default (0 = Unknown sentinel). This converts
+ * "unset required enum" from a silent `"unknown"` wire value into a clean
+ * omission so the API returns a clear `missing required field` error instead
+ * of a confusing 422.
+ */
+export function emitJsonPropertyAttributes(_wireName: string, options: { isRequiredEnum?: boolean } = {}): string[] {
+  if (options.isRequiredEnum) {
+    return [
+      `        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)]`,
+      `        [STJS.JsonIgnore(Condition = STJS.JsonIgnoreCondition.WhenWritingDefault)]`,
+    ];
+  }
+  // Convention-based: SnakeCaseLower naming policy handles the name mapping.
+  return [];
+}
+
+function mapPrimitive(ref: PrimitiveType): string {
+  if (ref.format === 'binary') return 'byte[]';
+  if (ref.format === 'int32') return 'int';
+  if (ref.format === 'int64') return 'long';
+  if (ref.format === 'date-time') return 'DateTimeOffset';
+  switch (ref.type) {
+    case 'string':
+      return 'string';
+    case 'integer':
+      return 'long';
+    case 'number':
+      return 'double';
+    case 'boolean':
+      return 'bool';
+    case 'unknown':
+      return 'object';
+  }
+}
+
+/**
+ * Track discriminated unions for downstream model generation.
+ * Key = generated base type name, Value = discriminator info.
+ */
+export const discriminatedUnions = new Map<
+  string,
+  { property: string; mapping: Record<string, string>; variantTypes: string[] }
+>();
+
+function joinUnionVariants(_ref: UnionType, variants: string[]): string {
+  if (_ref.compositionKind === 'allOf') {
+    return variants[0] ?? 'object';
+  }
+  const unique = [...new Set(variants)];
+  if (unique.length === 1) return unique[0];
+
+  // Discriminated union: register for converter generation and return first variant as base
+  if (_ref.discriminator && _ref.discriminator.mapping) {
+    const baseName = unique[0];
+    discriminatedUnions.set(baseName, {
+      property: _ref.discriminator.property,
+      mapping: _ref.discriminator.mapping,
+      variantTypes: unique,
+    });
+    // Use object with JsonConverter for discriminated unions since
+    // AnyOf<> doesn't support discriminator-based deserialization
+    return 'object';
+  }
+
+  if (unique.length >= 2 && unique.length <= 9) return `OneOf.OneOf<${unique.join(', ')}>`;
+  // OneOf supports arity 2-9. Higher-arity unions collapse to `object`,
+  // losing type information. Warn so the author knows the spec outgrew the
+  // runtime support instead of silently degrading.
+  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';
+}

package/src/dotnet/wrappers.ts

@@ -0,0 +1,197 @@
+import type { EmitterContext, ResolvedOperation, ResolvedWrapper } from '@workos/oagen';
+import {
+  fieldName as csFieldName,
+  methodName as csMethodName,
+  localName,
+  csLiteral,
+  clientFieldExpression,
+  httpMethodHelperName,
+  escapeXml,
+  emitXmlDoc,
+  humanize,
+  appendAsyncSuffix,
+  modelClassName,
+} from './naming.js';
+import { sortPathParamsByTemplateOrder } from './resources.js';
+import { resolveWrapperParams, formatWrapperDescription, type ResolvedWrapperParam } from '../shared/wrapper-utils.js';
+import { mapTypeRef, isValueTypeRef, isEnumRef, emitJsonPropertyAttributes } from './type-map.js';
+
+/**
+ * Generate C# wrapper method lines for union split operations.
+ */
+export function generateWrapperMethods(
+  _serviceType: string,
+  resolvedOp: ResolvedOperation,
+  ctx: EmitterContext,
+): string[] {
+  if (!resolvedOp.wrappers || resolvedOp.wrappers.length === 0) return [];
+
+  const lines: string[] = [];
+
+  for (const wrapper of resolvedOp.wrappers) {
+    const wrapperParams = resolveWrapperParams(wrapper, ctx);
+    lines.push('');
+    emitWrapperMethod(lines, resolvedOp, wrapper, wrapperParams, ctx);
+  }
+
+  return lines;
+}
+
+function emitWrapperMethod(
+  lines: string[],
+  resolvedOp: ResolvedOperation,
+  wrapper: ResolvedWrapper,
+  _wrapperParams: ResolvedWrapperParam[],
+  _ctx: EmitterContext,
+): void {
+  const op = resolvedOp.operation;
+  const methodStem = csMethodName(wrapper.name);
+  const method = appendAsyncSuffix(methodStem);
+  const optionsClass = `${methodStem}Options`;
+  const responseType = wrapper.responseModelName ? modelClassName(wrapper.responseModelName) : null;
+
+  // XML doc
+  lines.push(`        /// <summary>${formatWrapperDescription(wrapper.name)}.</summary>`);
+  for (const p of sortPathParamsByTemplateOrder(op)) {
+    const paramDesc = p.description ? escapeXml(p.description) : `The ${humanize(p.name)}.`;
+    lines.push(`        /// <param name="${localName(p.name)}">${paramDesc}</param>`);
+  }
+  lines.push(`        /// <param name="options">Request options.</param>`);
+  lines.push(`        /// <param name="requestOptions">Per-request configuration overrides.</param>`);
+  lines.push(`        /// <param name="cancellationToken">Cancellation token.</param>`);
+  if (responseType) {
+    lines.push(`        /// <returns>The <see cref="${responseType}"/> result.</returns>`);
+  }
+
+  // Signature
+  const sigParams: string[] = [];
+  const argNames: string[] = [];
+  for (const p of sortPathParamsByTemplateOrder(op)) {
+    const name = localName(p.name);
+    sigParams.push(`string ${name}`);
+    argNames.push(name);
+  }
+  sigParams.push(`${optionsClass} options`);
+  argNames.push('options');
+  sigParams.push('RequestOptions? requestOptions = null');
+  argNames.push('requestOptions');
+  sigParams.push('CancellationToken cancellationToken = default');
+  argNames.push('cancellationToken');
+
+  const returnType = responseType ? `Task<${responseType}>` : 'Task';
+  lines.push(`        public async ${returnType} ${method}(${sigParams.join(', ')})`);
+  lines.push('        {');
+
+  // Set defaults on options
+  for (const [key, value] of Object.entries(wrapper.defaults)) {
+    lines.push(`            options.${csFieldName(key)} = ${csLiteral(value)};`);
+  }
+
+  // Set inferred fields from client. ClientId is required: fail loudly via RequireClientId()
+  // so that callers who forgot to configure it get a clear error instead of a 422 from the API.
+  for (const field of wrapper.inferFromClient) {
+    if (field === 'client_id') {
+      lines.push(`            options.${csFieldName(field)} = this.Client.RequireClientId();`);
+    } else {
+      lines.push(
+        `            options.${csFieldName(field)} = this.Client.${clientFieldExpression(field)} ?? string.Empty;`,
+      );
+    }
+  }
+
+  // Build path
+  let pathExpr: string;
+  if (op.pathParams.length > 0) {
+    let interpolated = op.path;
+    for (const p of sortPathParamsByTemplateOrder(op)) {
+      interpolated = interpolated.replace(`{${p.name}}`, `{Uri.EscapeDataString(${localName(p.name)})}`);
+    }
+    pathExpr = `$"${interpolated}"`;
+  } else {
+    pathExpr = `"${op.path}"`;
+  }
+
+  // Use the Service base-class helper so wrappers read as one-liners.
+  const helper = httpMethodHelperName(op.httpMethod);
+  if (responseType) {
+    lines.push(
+      `            return await this.${helper}<${responseType}>(${pathExpr}, options, requestOptions, cancellationToken);`,
+    );
+  } else if (helper === 'DeleteAsync') {
+    lines.push(`            await this.${helper}(${pathExpr}, options, requestOptions, cancellationToken);`);
+  } else {
+    lines.push(`            await this.${helper}<object>(${pathExpr}, options, requestOptions, cancellationToken);`);
+  }
+
+  lines.push('        }');
+
+  lines.push('');
+  lines.push(`        /// <summary>Compatibility wrapper for <see cref="${method}"/>.</summary>`);
+  lines.push(`        public Task${responseType ? `<${responseType}>` : ''} ${methodStem}(${sigParams.join(', ')})`);
+  lines.push('        {');
+  lines.push(`            return this.${method}(${argNames.join(', ')});`);
+  lines.push('        }');
+}
+
+// NOTE: T26 (wrapper DRY) — the AuthenticateWith* wrappers share a small
+// SendAuthenticateAsync helper at runtime to avoid 8x copies of the same
+// MakeAPIRequest call. The helper itself lives in UserManagementService.cs as
+// a hand-maintained method (it can't easily be expressed as a generic because
+// the eight options classes don't share an interface). Keeping each generated
+// wrapper's body short is the practical part of the DRY win.
+
+/**
+ * Generate wrapper options classes. Called from resources.ts options generation.
+ */
+export function generateWrapperOptionsClasses(resolvedOp: ResolvedOperation, ctx: EmitterContext): string[] {
+  if (!resolvedOp.wrappers || resolvedOp.wrappers.length === 0) return [];
+
+  const lines: string[] = [];
+
+  for (const wrapper of resolvedOp.wrappers) {
+    const wrapperParams = resolveWrapperParams(wrapper, ctx);
+    const optionsClass = `${csMethodName(wrapper.name)}Options`;
+
+    lines.push('');
+    lines.push(`    public class ${optionsClass} : BaseOptions`);
+    lines.push('    {');
+
+    // Exposed params
+    for (const { paramName, field, isOptional } of wrapperParams) {
+      const csField = csFieldName(paramName);
+      const csType = field ? resolveSimpleCsType(field.type, isOptional) : isOptional ? 'string?' : 'string';
+      const needsDefault = !isOptional && !csType.endsWith('?') && !(field && isValueTypeRef(field.type));
+      const initializer = needsDefault ? ' = default!;' : '';
+
+      const isRequiredEnum = !isOptional && !!field && isEnumRef(field.type);
+      lines.push(...emitXmlDoc(field?.description, '        '));
+      lines.push(...emitJsonPropertyAttributes(paramName, { isRequiredEnum }));
+      lines.push(`        public ${csType} ${csField} { get; set; }${initializer}`);
+      lines.push('');
+    }
+
+    // Hidden fields (defaults + inferred)
+    for (const key of Object.keys(wrapper.defaults)) {
+      const csField = csFieldName(key);
+      lines.push(`        internal string ${csField} { get; set; } = default!;`);
+      lines.push('');
+    }
+    for (const key of wrapper.inferFromClient) {
+      const csField = csFieldName(key);
+      // Skip if already added as a default
+      if (Object.keys(wrapper.defaults).includes(key)) continue;
+      lines.push(`        internal string ${csField} { get; set; } = default!;`);
+      lines.push('');
+    }
+
+    lines.push('    }');
+  }
+
+  return lines;
+}
+
+function resolveSimpleCsType(ref: any, isOptional: boolean): string {
+  const base = mapTypeRef(ref);
+  if (isOptional && !base.endsWith('?')) return `${base}?`;
+  return base;
+}

package/src/go/client.ts

@@ -2,8 +2,9 @@ import type { ApiSpec, EmitterContext, GeneratedFile, Service } from '@workos/oa
 import { toPascalCase, toSnakeCase } from '@workos/oagen';
 // naming utilities used indirectly via resolveResourceClassName
 import { resolveResourceClassName } from './resources.js';
-import { unexportedName } from './naming.js';
+import { className, unexportedName } from './naming.js';
 import { getMountTarget } from '../shared/resolved-ops.js';
+import { NON_SPEC_SERVICES } from '../shared/non-spec-services.js';
 
 /**
  * Generate the Go client file with service accessors.
@@ -15,6 +16,16 @@ export function generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFil
   return [generateWorkOSFile(spec, ctx)];
 }
 
+/**
+ * Non-spec services marked with `hasClientAccessor: true` (passwordless, vault)
+ * are included in the generated Client struct, constructor, and accessor methods
+ * — identical to spec-driven services. Their service type (e.g. PasswordlessService)
+ * is defined in a hand-written @oagen-ignore-file, but the Client wiring is generated.
+ *
+ * Other non-spec modules (webhook_verification, actions, etc.) remain fully
+ * self-contained in their @oagen-ignore-file files.
+ */
+
 /**
  * Deduplicate services by mount target.
  */
@@ -72,6 +83,8 @@ function generateWorkOSFile(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
   lines.push('\tbaseURL      string');
   lines.push('\thttpClient   *http.Client');
   lines.push('\tmaxRetries   int');
+  lines.push('\tlogger       Logger');
+  lines.push('\tappInfo      appInfo');
   lines.push('');
   // Service fields
   for (const service of topLevel) {
@@ -80,6 +93,11 @@ function generateWorkOSFile(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
     const serviceTypeName = serviceType(resolvedName);
     lines.push(`\t${fieldNameStr} *${serviceTypeName}`);
   }
+  // Non-spec service fields (hand-written types, generated wiring)
+  for (const ns of NON_SPEC_SERVICES.filter((s) => s.hasClientAccessor)) {
+    const name = className(toPascalCase(ns.id));
+    lines.push(`\t${unexportedName(name)} *${serviceType(name)}`);
+  }
   lines.push('}');
   lines.push('');
 
@@ -102,6 +120,11 @@ function generateWorkOSFile(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
     const serviceTypeName = serviceType(resolvedName);
     lines.push(`\tc.${fieldNameStr} = &${serviceTypeName}{client: c}`);
   }
+  // Initialize non-spec services
+  for (const ns of NON_SPEC_SERVICES.filter((s) => s.hasClientAccessor)) {
+    const name = className(toPascalCase(ns.id));
+    lines.push(`\tc.${unexportedName(name)} = &${serviceType(name)}{client: c}`);
+  }
   lines.push('\treturn c');
   lines.push('}');
   lines.push('');
@@ -118,7 +141,16 @@ function generateWorkOSFile(spec: ApiSpec, ctx: EmitterContext): GeneratedFile {
     lines.push('}');
     lines.push('');
   }
-
+  // Non-spec service accessor methods
+  for (const ns of NON_SPEC_SERVICES.filter((s) => s.hasClientAccessor)) {
+    const name = className(toPascalCase(ns.id));
+    const typeName = serviceType(name);
+    lines.push(`// ${name} returns the ${name} service.`);
+    lines.push(`func (c *Client) ${name}() *${typeName} {`);
+    lines.push(`\treturn c.${unexportedName(name)}`);
+    lines.push('}');
+    lines.push('');
+  }
   return {
     path: `${ctx.namespace}.go`,
     content: lines.join('\n'),
@@ -137,5 +169,5 @@ function singularizePascal(name: string): string {
 }
 
 function serviceType(name: string): string {
-  return `${unexportedName(singularizePascal(name))}Service`;
+  return `${className(singularizePascal(name))}Service`;
 }

package/src/go/enums.ts

@@ -29,6 +29,10 @@ export function generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile
     if (canonicalName) {
       const aliasType = className(enumDef.name);
       const canonicalType = className(canonicalName);
+      // Skip when different IR names map to the same Go type (e.g. synthetic
+      // enums from enrichModelsFromSpec whose underscore names collapse to the
+      // same PascalCase as the original enum).
+      if (aliasType === canonicalType) continue;
       lines.push(`// ${aliasType} is an alias for ${canonicalType}.`);
       lines.push(`type ${aliasType} = ${canonicalType}`);
       lines.push('');

package/src/go/index.ts

@@ -10,7 +10,7 @@ import type {
 } from '@workos/oagen';
 
 import { generateModels } from './models.js';
-import { enrichModelsFromSpec } from '../shared/model-utils.js';
+import { enrichModelsFromSpec, getSyntheticEnums } from '../shared/model-utils.js';
 import { generateEnums } from './enums.js';
 import { generateResources } from './resources.js';
 import { generateClient } from './client.js';
@@ -37,7 +37,10 @@ export const goEmitter: Emitter = {
   },
 
   generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
-    return ensureTrailingNewlines(generateEnums(enums, ctx));
+    // Merge synthetic enums produced during model enrichment (inline oneOf
+    // definitions) so they get proper type definitions in enums.go.
+    const syntheticEnums = getSyntheticEnums();
+    return ensureTrailingNewlines(generateEnums([...enums, ...syntheticEnums], ctx));
   },
 
   generateResources(services: Service[], ctx: EmitterContext): GeneratedFile[] {
@@ -69,12 +72,17 @@ export const goEmitter: Emitter = {
     return '// Code generated by oagen. DO NOT EDIT.';
   },
 
-  formatCommand(targetDir: string): FormatCommand | null {
-    // Pass targetDir as the first path so gofmt formats the entire directory
-    // (including hand-maintained files), not just the generated file list.
+  formatCommand(_targetDir: string): FormatCommand | null {
+    // oagen appends all generated file paths (including .json fixtures) to the
+    // format command. gofmt errors on non-.go files, so filter them out.
+    // Same pattern as the Python emitter's ruff wrapper.
     return {
-      cmd: 'gofmt',
-      args: ['-w', targetDir],
+      cmd: 'bash',
+      args: [
+        '-c',
+        'GO_FILES=$(printf "%s\\n" "$@" | grep "\\.go$"); [ -n "$GO_FILES" ] && echo "$GO_FILES" | xargs gofmt -w',
+        '--',
+      ],
       batchSize: 999999,
     };
   },

package/src/go/models.ts

@@ -59,9 +59,14 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
       if (batchedAliases.has(model.name)) continue;
 
       const canonicalStruct = className(canonicalName);
+      // Skip when different IR names map to the same Go type (e.g. synthetic
+      // models from enrichModelsFromSpec whose underscore names collapse to the
+      // same PascalCase as the original model).
+      if (structName === canonicalStruct) continue;
+
       const hash = modelHashMap.get(model.name)!;
       const groupNames = hashGroups.get(hash) ?? [];
-      const aliases = groupNames.filter((n) => aliasOf.has(n));
+      const aliases = groupNames.filter((n) => aliasOf.has(n) && className(n) !== className(aliasOf.get(n)!));
 
       if (aliases.length >= 5) {
         // Batch emit all aliases for this group at once

package/src/go/naming.ts

@@ -1,24 +1,15 @@
 import type { Operation, Service, EmitterContext } from '@workos/oagen';
 import { toPascalCase, toSnakeCase } from '@workos/oagen';
 import { buildResolvedLookup, lookupMethodName, getMountTarget } from '../shared/resolved-ops.js';
-import { stripUrnPrefix } from '../shared/naming-utils.js';
+import { stripUrnPrefix, applyAcronymFixes } from '../shared/naming-utils.js';
 
 /**
- * Acronym map: after PascalCase conversion, fix known acronyms to all-caps Go convention.
+ * Go-specific acronym extensions beyond the shared base set.
+ * Go convention requires ALL_CAPS for well-known initialisms.
  */
-const ACRONYM_FIXES: [RegExp, string][] = [
-  [/Workos/g, 'WorkOS'],
-  [/Sso/g, 'SSO'],
-  [/Mfa/g, 'MFA'],
+const GO_EXTRA_ACRONYM_FIXES: [RegExp, string][] = [
   [/Jwks(?=[A-Z]|$)/g, 'JWKS'],
-  [/Jwt/g, 'JWT'],
   [/Totp(?=[A-Z]|$)/g, 'TOTP'],
-  [/Cors/g, 'CORS'],
-  [/Saml/g, 'SAML'],
-  [/Scim/g, 'SCIM'],
-  [/Rbac/g, 'RBAC'],
-  [/Oauth/g, 'OAuth'],
-  [/Oidc/g, 'OIDC'],
   [/Api(?=[A-Z]|$)/g, 'API'],
   [/Urls(?=[A-Z]|$)/g, 'URLs'],
   [/Url(?=[A-Z]|$)/g, 'URL'],
@@ -45,10 +36,7 @@ function fixTrailingId(s: string): string {
 
 /** Apply all Go acronym conventions to a PascalCase string. */
 function applyAcronyms(s: string): string {
-  let result = s;
-  for (const [pattern, replacement] of ACRONYM_FIXES) {
-    result = result.replace(pattern, replacement);
-  }
+  let result = applyAcronymFixes(s, GO_EXTRA_ACRONYM_FIXES);
   result = fixTrailingId(result);
   return result;
 }