@workos/oagen-emitters 0.6.5 → 0.6.7

package/dist/plugin.mjs

@@ -1,2 +1,2 @@
-import { t as workosEmittersPlugin } from "./plugin-BV_wDWDO.mjs";
+import { t as workosEmittersPlugin } from "./plugin-Bk0xWTQC.mjs";
 export { workosEmittersPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "description": "WorkOS' oagen emitters",
   "license": "MIT",
   "author": "WorkOS",

package/src/dotnet/index.ts

@@ -103,7 +103,14 @@ export const dotnetEmitter: Emitter = {
       return m;
     });
 
-    const discCtx: DiscriminatorContext = { discriminatorBases, variantToBase };
+    // Build a map of base model name → discriminator wire-property name so the
+    // model emitter can mark the discriminator field as internal-set.
+    const discriminatorProperties = new Map<string, string>();
+    for (const [baseName, disc] of modelDiscriminators) {
+      discriminatorProperties.set(baseName, disc.property);
+    }
+
+    const discCtx: DiscriminatorContext = { discriminatorBases, variantToBase, discriminatorProperties };
     const files = generateModels(dotnetModels, c, discCtx);
 
     // Generate discriminator converters for oneOf unions with discriminator
@@ -161,8 +168,10 @@ export const dotnetEmitter: Emitter = {
 
     // Generate converters for discriminated base models (model-level
     // discriminators detected by enrichModelsFromSpec, e.g. EventSchema).
-    // Uses Populate to avoid infinite recursion with the [JsonConverter]
-    // attribute applied to the base class.
+    // ReadJson uses Populate (not Deserialize) to avoid infinite recursion
+    // with the [JsonConverter] attribute applied to the base class.
+    // CanWrite is false so serialization uses the default path and never
+    // re-enters WriteJson.
     for (const [baseName, disc] of modelDiscriminators) {
       const baseClass = modelClassName(baseName);
       const converterName = `${baseClass}DiscriminatorConverter`;
@@ -179,6 +188,8 @@ export const dotnetEmitter: Emitter = {
       lines.push(`    /// </summary>`);
       lines.push(`    public class ${converterName} : Newtonsoft.Json.JsonConverter`);
       lines.push('    {');
+      lines.push('        public override bool CanWrite => false;');
+      lines.push('');
       lines.push(
         `        public override bool CanConvert(Type objectType) => typeof(${baseClass}).IsAssignableFrom(objectType);`,
       );
@@ -208,7 +219,9 @@ export const dotnetEmitter: Emitter = {
         '        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object? value, Newtonsoft.Json.JsonSerializer serializer)',
       );
       lines.push('        {');
-      lines.push('            serializer.Serialize(writer, value);');
+      lines.push(
+        '            throw new NotImplementedException("Serialization is handled by the default serializer.");',
+      );
       lines.push('        }');
       lines.push('    }');
       lines.push('}');

package/src/dotnet/models.ts

@@ -31,6 +31,8 @@ export interface DiscriminatorContext {
   discriminatorBases: Set<string>;
   /** Maps variant model name → base model name. */
   variantToBase: Map<string, string>;
+  /** Maps base model name → wire name of the discriminator property. */
+  discriminatorProperties?: Map<string, string>;
 }
 
 /**
@@ -161,6 +163,12 @@ export function generateModels(models: Model[], ctx: EmitterContext, discCtx?: D
       let initializer = '';
       let setterModifier = '';
 
+      // On a discriminated union base, the discriminator property (e.g. "event")
+      // should be non-public-settable even though it lacks a single const value
+      // (each variant has a different value). Consumers must never mutate it.
+      const discProp = isDiscBase ? discCtx?.discriminatorProperties?.get(model.name) : undefined;
+      const isDiscriminatorField = discProp !== undefined && field.name === discProp;
+
       if (constInit !== null && !isOptional) {
         // Discriminator-style single-value enum/literal: emit with a const
         // initializer and a non-public setter so callers can't drift the
@@ -170,6 +178,14 @@ export function generateModels(models: Model[], ctx: EmitterContext, discCtx?: D
         csType = baseType;
         initializer = ` = ${constInit};`;
         setterModifier = 'internal ';
+      } else if (isDiscriminatorField) {
+        // Discriminator property on the base class: varies per variant but
+        // should still be non-public-settable so consumers can't change it.
+        csType = baseType;
+        if (!isAlreadyNullable && !isValueTypeRef(field.type)) {
+          initializer = ' = default!;';
+        }
+        setterModifier = 'internal ';
       } else if (isOptional) {
         if (isAlreadyNullable) {
           csType = baseType;
@@ -219,6 +235,14 @@ export function generateModels(models: Model[], ctx: EmitterContext, discCtx?: D
       lines.push(`        /// <paramref name="key"/> coerced to <typeparamref name="T"/>, or the default`);
       lines.push(`        /// value when the key is missing or the value is not convertible.`);
       lines.push(`        /// </summary>`);
+      if (isDiscBase) {
+        lines.push(`        /// <remarks>`);
+        lines.push(`        /// Variant subclasses provide strongly-typed <c>${dict.csName}</c> properties that`);
+        lines.push(`        /// shadow this dictionary. This accessor is intended for forward-compatible handling`);
+        lines.push(`        /// of types not yet known to this SDK version. For recognized types, cast to the`);
+        lines.push(`        /// specific subclass and access its typed <c>${dict.csName}</c> property directly.`);
+        lines.push(`        /// </remarks>`);
+      }
       lines.push(`        /// <typeparam name="T">Expected value type.</typeparam>`);
       lines.push(`        /// <param name="key">The key to look up.</param>`);
       lines.push(`        public T? Get${dict.csName}Attribute<T>(string key)`);

package/src/go/fixtures.ts

@@ -24,12 +24,11 @@ export const ID_PREFIXES: Record<string, string> = {
 /**
  * Generate JSON fixture files for test data.
  */
-export function generateFixtures(spec: {
-  models: Model[];
-  enums: Enum[];
-  services: any[];
-}): { path: string; content: string }[] {
-  if (spec.models.length === 0) return [];
+export function generateFixtures(spec: { models: Model[]; enums: Enum[]; services: any[] }): {
+  files: { path: string; content: string }[];
+  pathRewrites: Map<string, string>;
+} {
+  if (spec.models.length === 0) return { files: [], pathRewrites: new Map() };
 
   const modelMap = new Map(spec.models.map((m) => [m.name, m]));
   const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
@@ -96,7 +95,7 @@ export function generateFixtures(spec: {
   // Remove duplicate files (they'll reference the canonical)
   const deduped = files.filter((f) => !pathRewrites.has(f.path));
 
-  return deduped;
+  return { files: deduped, pathRewrites };
 }
 
 function unwrapListModel(model: Model, modelMap: Map<string, Model>): Model | null {

package/src/go/models.ts

@@ -166,10 +166,27 @@ function makeOptional(goType: string): string {
 }
 
 function structuralHash(model: Model): string {
-  return model.fields
+  const fieldHash = model.fields
     .map((f) => `${f.name}:${JSON.stringify(f.type)}:${f.required}`)
     .sort()
     .join('|');
+  // Include entity domain for CRUD-prefixed models to prevent cross-domain
+  // aliasing (e.g. UpdateGroup vs UpdateAuthorizationPermission have identical
+  // fields but belong to different API domains and should stay separate types).
+  const domain = crudEntityDomain(model.name);
+  return domain ? `${domain}::${fieldHash}` : fieldHash;
+}
+
+const CRUD_PREFIXES = ['Create', 'Update', 'Delete', 'Get', 'List'];
+
+/** Strip CRUD verb prefix to get the entity name, or null if no prefix matches. */
+function crudEntityDomain(name: string): string | null {
+  for (const prefix of CRUD_PREFIXES) {
+    if (name.startsWith(prefix) && name.length > prefix.length) {
+      return name.slice(prefix.length);
+    }
+  }
+  return null;
 }
 
 /** Known acronyms to preserve as single tokens during humanization. */

package/src/go/tests.ts

@@ -72,7 +72,7 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   });
 
   // Generate fixture JSON files
-  const fixtures = generateFixtures(spec);
+  const { files: fixtures, pathRewrites: fixtureRewrites } = generateFixtures(spec);
   for (const fixture of fixtures) {
     files.push({
       path: fixture.path,
@@ -97,7 +97,7 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   for (const { name: mountName, operations } of testEntries) {
     if (operations.length === 0) continue;
     const mergedService: Service = { name: mountName, operations };
-    const testFile = generateServiceTest(mergedService, spec, ctx, accessPaths);
+    const testFile = generateServiceTest(mergedService, spec, ctx, accessPaths, fixtureRewrites);
     if (testFile) files.push(testFile);
   }
 
@@ -109,6 +109,7 @@ function generateServiceTest(
   spec: ApiSpec,
   ctx: EmitterContext,
   _accessPaths: Map<string, string>,
+  fixtureRewrites: Map<string, string>,
 ): GeneratedFile | null {
   if (service.operations.length === 0) return null;
 
@@ -213,6 +214,10 @@ function generateServiceTest(
             }
           }
           fixturePath = `testdata/list_${fileName(resolved.name)}.json`;
+          // If this fixture was deduplicated, use the canonical path
+          if (fixtureRewrites.has(fixturePath)) {
+            fixturePath = fixtureRewrites.get(fixturePath)!;
+          }
         }
       }
 
@@ -302,7 +307,10 @@ function generateServiceTest(
       // Success test
       const respModel = plan.responseModelName;
       const isArrayResponse = !isPaginated && op.response?.kind === 'array';
-      const fixturePath = `testdata/${fileName(respModel)}.json`;
+      let fixturePath = `testdata/${fileName(respModel)}.json`;
+      if (fixtureRewrites.has(fixturePath)) {
+        fixturePath = fixtureRewrites.get(fixturePath)!;
+      }
       const expectedPath = buildExpectedPath(op);
 
       const httpMethodUpper = op.httpMethod.toUpperCase();
@@ -406,7 +414,10 @@ function generateServiceTest(
       const wrapperParamsStruct = paramsStructName(resolvedName, wrapperMethod);
       const responseType = wrapper.responseModelName;
       const testName = `Test${accessorName}_${wrapperMethod}`;
-      const fixturePath = responseType ? `testdata/${fileName(responseType)}.json` : null;
+      let fixturePath = responseType ? `testdata/${fileName(responseType)}.json` : null;
+      if (fixturePath && fixtureRewrites.has(fixturePath)) {
+        fixturePath = fixtureRewrites.get(fixturePath)!;
+      }
 
       const wrapperCallArgs: string[] = ['context.Background()'];
       for (const p of sortPathParamsByTemplateOrder(op)) {

package/src/python/client.ts

@@ -163,15 +163,17 @@ function generateWorkOSClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
       lines.push(importLine);
     }
   }
-  // Non-spec service imports — wrapped in ignore markers so the merger
-  // matches them positionally and doesn't displace them.
-  lines.push('');
-  lines.push('# @oagen-ignore-start — non-spec service imports (hand-maintained)');
+  // Non-spec service imports — emitted as plain imports (not wrapped in
+  // ignore markers). The overwriteWithPreservedRegions() machinery in oagen
+  // relocates top-level ignore blocks to EOF because they have no containing
+  // class, stripping the markers from the imports while spliceExtraImports()
+  // preserves the bare import lines. Emitting them directly avoids the
+  // displacement entirely; spliceExtraImports() will preserve any additional
+  // hand-added imports from the existing file on subsequent regenerations.
   for (const s of NON_SPEC_SERVICES) {
     const w = PYTHON_NON_SPEC_WIRING[s.id];
     if (w) lines.push(w.importLine);
   }
-  lines.push('# @oagen-ignore-end');
   lines.push('');
   lines.push('');
 

package/test/dotnet/models.test.ts

@@ -255,4 +255,81 @@ describe('dotnet/models', () => {
     expect(orgFile).toBeDefined();
     expect(orgFile.content).toContain('List<OrganizationDomain>');
   });
+
+  it('emits internal set on discriminator property of base class', () => {
+    const models: Model[] = [
+      {
+        name: 'EventSchema',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'event', type: { kind: 'primitive', type: 'string' }, required: true },
+          {
+            name: 'data',
+            type: { kind: 'map', valueType: { kind: 'primitive', type: 'unknown' } },
+            required: true,
+          },
+        ],
+      },
+      {
+        name: 'UserCreated',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'event', type: { kind: 'literal', value: 'user.created' }, required: true },
+          { name: 'data', type: { kind: 'model', name: 'UserCreatedData' }, required: true },
+        ],
+      },
+      {
+        name: 'UserCreatedData',
+        fields: [{ name: 'user_id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+
+    primeEnumAliases([]);
+    const discCtx = {
+      discriminatorBases: new Set(['EventSchema']),
+      variantToBase: new Map([['UserCreated', 'EventSchema']]),
+      discriminatorProperties: new Map([['EventSchema', 'event']]),
+    };
+    const files = generateModels(models, { ...ctx, spec: { ...emptySpec, models } }, discCtx);
+
+    const baseFile = files.find((f) => f.path.includes('EventSchema.cs'))!;
+    expect(baseFile).toBeDefined();
+
+    // The discriminator property "event" should have internal set
+    expect(baseFile.content).toContain('Event { get; internal set; }');
+    // Non-discriminator required fields should NOT have internal set
+    expect(baseFile.content).toContain('Id { get; set; }');
+  });
+
+  it('adds remarks to dictionary accessors on discriminator base class', () => {
+    const models: Model[] = [
+      {
+        name: 'EventSchema',
+        fields: [
+          { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+          { name: 'event', type: { kind: 'primitive', type: 'string' }, required: true },
+          {
+            name: 'data',
+            type: { kind: 'map', valueType: { kind: 'primitive', type: 'unknown' } },
+            required: true,
+          },
+        ],
+      },
+    ];
+
+    primeEnumAliases([]);
+    const discCtx = {
+      discriminatorBases: new Set(['EventSchema']),
+      variantToBase: new Map<string, string>(),
+      discriminatorProperties: new Map([['EventSchema', 'event']]),
+    };
+    const files = generateModels(models, { ...ctx, spec: { ...emptySpec, models } }, discCtx);
+
+    const baseFile = files.find((f) => f.path.includes('EventSchema.cs'))!;
+    expect(baseFile).toBeDefined();
+
+    // Dictionary accessors on discriminator bases should have a remarks note
+    expect(baseFile.content).toContain('/// <remarks>');
+    expect(baseFile.content).toContain('forward-compatible');
+  });
 });