@workos/oagen-emitters 0.6.6 → 0.6.7

package/dist/plugin.mjs

@@ -1,2 +1,2 @@
-import { t as workosEmittersPlugin } from "./plugin-BgVrq-hM.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.6",
+  "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
@@ -181,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);`,
       );
@@ -206,8 +215,6 @@ export const dotnetEmitter: Emitter = {
       lines.push('            return target;');
       lines.push('        }');
       lines.push('');
-      lines.push('        public override bool CanWrite => false;');
-      lines.push('');
       lines.push(
         '        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object? value, Newtonsoft.Json.JsonSerializer serializer)',
       );

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/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

@@ -307,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();
@@ -411,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/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');
+  });
 });