@workos/oagen-emitters 0.6.6 → 0.6.8

package/src/ruby/resources.ts

@@ -1,6 +1,14 @@
 import type { Service, EmitterContext, GeneratedFile, Operation, TypeRef, Parameter, Model } from '@workos/oagen';
 import { planOperation } from '@workos/oagen';
-import { className, fieldName, fileName, methodName, safeParamName, resolveMethodName } from './naming.js';
+import {
+  className,
+  fieldName,
+  fileName,
+  methodName,
+  safeParamName,
+  resolveMethodName,
+  scopedGroupVariantClassName,
+} from './naming.js';
 import { mapTypeRefForYard } from './type-map.js';
 import {
   buildResolvedLookup,
@@ -13,6 +21,7 @@ import {
 } from '../shared/resolved-ops.js';
 import { isListWrapperModel } from '../shared/model-utils.js';
 import { generateWrapperMethods, collectWrapperResponseModels } from './wrappers.js';
+import { buildGroupOwnerMap, collectVariantsForMountTarget, emitInlineVariantClass } from './parameter-groups.js';
 
 /**
  * Generate Ruby resource (service) classes from IR services.
@@ -35,6 +44,11 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
     if (isListWrapperModel(m)) listWrapperModels.set(m.name, m);
   }
 
+  // Resolve groupName -> owner mountTarget once per generation pass; every
+  // dispatcher and YARD `@param` reference resolves variant classes through
+  // this map so cross-resource references stay consistent.
+  const groupOwners = buildGroupOwnerMap(ctx);
+
   for (const [mountTarget, group] of groups) {
     const cls = className(mountTarget);
     const file = fileName(mountTarget);
@@ -88,6 +102,7 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
         modelByName,
         listWrapperModels,
         requires,
+        groupOwners,
       });
       methodBodies.push(body);
 
@@ -121,6 +136,18 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
     }
     lines.push('module WorkOS');
     lines.push(`  class ${cls}`);
+
+    // Inline parameter-group variant classes owned by this mount target.
+    // Zeitwerk's `loader.collapse` flattens `lib/workos/<service>/` so files
+    // there can't define `WorkOS::<Service>::*` constants — variants must
+    // live inside the service's own file. Matches Python's per-resource
+    // dataclass layout.
+    const variants = collectVariantsForMountTarget(ctx, ctx.spec.models as Model[], mountTarget);
+    for (const v of variants) {
+      for (const line of emitInlineVariantClass(v)) lines.push(line);
+      lines.push('');
+    }
+
     lines.push('    def initialize(client)');
     lines.push('      @client = client');
     lines.push('    end');
@@ -154,6 +181,7 @@ function emitMethod(args: {
   modelByName: Map<string, Model>;
   listWrapperModels: Map<string, Model>;
   requires: Set<string>;
+  groupOwners: Map<string, string>;
 }): string {
   const {
     op,
@@ -166,9 +194,19 @@ function emitMethod(args: {
     modelByName,
     listWrapperModels,
     requires,
+    groupOwners,
   } = args;
   void enumNames;
 
+  /** Fully-qualified Ruby constant for a variant (e.g. WorkOS::UserManagement::PasswordPlaintext). */
+  const variantClassRef = (group: { name: string }, variantName: string): string => {
+    const owner = groupOwners.get(group.name);
+    if (!owner) {
+      throw new Error(`No owner mount target found for parameter group '${group.name}'`);
+    }
+    return scopedGroupVariantClassName(owner, group.name, variantName);
+  };
+
   const plan = planOperation(op);
   const lines: string[] = [];
 
@@ -177,8 +215,11 @@ function emitMethod(args: {
   const groupedParamNames = collectGroupedParamNames(op);
   const queryParams = (op.queryParams ?? []).filter((q) => !groupedParamNames.has(q.name));
 
-  // Request body params: if body is a model, expand its fields.
-  const bodyFields = getRequestBodyFields(op, hiddenParams, modelByName);
+  // Request body params: if body is a model, expand its fields. Drop any field
+  // whose name is also a parameter-group name — those are dispatched by the
+  // group kwarg below, so emitting them as flat kwargs would shadow the group
+  // and cause `String#[Symbol]` TypeErrors when the dispatcher reads `:type`.
+  const bodyFields = getRequestBodyFields(op, hiddenParams, modelByName).filter((f) => !groupedParamNames.has(f.name));
 
   // Detect path/body name collisions and build a rename map for body fields.
   // When a body field's snake_case name matches a path param, prefix with "body_"
@@ -269,7 +310,16 @@ function emitMethod(args: {
   sigParts.push('request_options: {}');
 
   // YARD docs.
-  const doc = buildYardDoc(op, pathParams, queryParams, bodyFields, hiddenParams, bodyFieldRenames, listWrapperModels);
+  const doc = buildYardDoc(
+    op,
+    pathParams,
+    queryParams,
+    bodyFields,
+    hiddenParams,
+    bodyFieldRenames,
+    listWrapperModels,
+    variantClassRef,
+  );
   for (const line of doc) lines.push(`    ${line}`);
 
   // Signature.
@@ -309,30 +359,41 @@ function emitMethod(args: {
   const groupsGoToQuery = hasGroups && !hasBodyMethod;
   const hasQuery = qEntries.length > 0 || groupsGoToQuery;
   if (hasQuery) {
+    // Skip `.compact` when no entry can be nil — required kwargs are always
+    // passed (Ruby raises ArgumentError otherwise), so the literal has no nil
+    // values to drop. Group dispatch happens after the literal is built and
+    // doesn't contribute potentially-nil entries either.
+    const queryHasNilable = qEntries.some((q) => !q.required);
+    const queryCompact = queryHasNilable ? '.compact' : '';
     lines.push('      params = {');
     for (let i = 0; i < qEntries.length; i++) {
       const q = qEntries[i];
       const sep = i === qEntries.length - 1 && !groupsGoToQuery ? '' : ',';
       lines.push(`        ${rubyStringLit(q.name)} => ${safeParamName(q.name)}${sep}`);
     }
-    lines.push('      }.compact');
+    lines.push(`      }${queryCompact}`);
 
     if (groupsGoToQuery) {
-      // Parameter group dispatch: merge grouped params into the query hash
+      // Parameter group dispatch: callers pass a typed variant class instance
+      // (e.g. `WorkOS::ParentResourceById`); we pattern-match on its class
+      // and forward its readers into the query hash.
       for (const group of op.parameterGroups ?? []) {
         const prop = fieldName(group.name);
         if (group.optional) {
           lines.push(`      if ${prop}`);
-          lines.push(`        case ${prop}[:type]`);
+          lines.push(`        case ${prop}`);
         } else {
-          lines.push(`      case ${prop}[:type]`);
+          lines.push(`      case ${prop}`);
         }
         for (const variant of group.variants) {
-          lines.push(`      when ${rubyStringLit(variant.name)}`);
+          const variantClass = variantClassRef(group, variant.name);
+          lines.push(`      when ${variantClass}`);
           for (const p of variant.parameters) {
-            lines.push(`        params[${rubyStringLit(p.name)}] = ${prop}[:${fieldName(p.name)}]`);
+            lines.push(`        params[${rubyStringLit(p.name)}] = ${prop}.${fieldName(p.name)}`);
           }
         }
+        lines.push(`      else`);
+        lines.push(`        raise ArgumentError, ${dispatchErrorLiteral(group, prop, variantClassRef)}`);
         lines.push('      end');
         if (group.optional) {
           lines.push('      end');
@@ -341,8 +402,12 @@ function emitMethod(args: {
     }
   }
 
-  // Request body
-  const hasBody = bodyFields.length > 0 && !['get', 'head'].includes(method_http);
+  // Request body. Emit when there are non-group body fields OR a parameter
+  // group dispatches into the body — the latter case matters when an
+  // operation's body is exclusively managed by a group (e.g.
+  // update_organization_membership's `role`), where filtering the group's
+  // leaves leaves bodyFields empty but the request still needs a payload.
+  const hasBody = (bodyFields.length > 0 && !['get', 'head'].includes(method_http)) || (hasGroups && hasBodyMethod);
 
   if (hasBody) {
     const bodyEntries: string[] = [];
@@ -355,35 +420,44 @@ function emitMethod(args: {
       const optKey = fc === 'client_secret' ? 'api_key' : fc;
       bodyEntries.push(`${rubyStringLit(fc)} => (request_options[:${optKey}] || @client.${clientProp})`);
     }
+    // Track whether any literal entry can be nil — defaults/inferFromClient
+    // resolve to non-nil values, so only optional body kwargs are nilable.
+    let bodyHasNilable = false;
     for (const f of bodyFields) {
       if (hiddenParams.has(f.name)) continue;
       bodyEntries.push(`${rubyStringLit(f.name)} => ${bodyKwargName(f.name)}`);
+      if (!f.required) bodyHasNilable = true;
     }
+    const bodyCompact = bodyHasNilable ? '.compact' : '';
     lines.push('      body = {');
     for (let i = 0; i < bodyEntries.length; i++) {
       const sep = i === bodyEntries.length - 1 ? '' : ',';
       lines.push(`        ${bodyEntries[i]}${sep}`);
     }
-    lines.push('      }.compact');
+    lines.push(`      }${bodyCompact}`);
 
     // Parameter group dispatch into body for POST/PUT/PATCH so sensitive
     // fields (passwords, role slugs) never leak into the URL query string.
     // DELETE groups are already handled via query above (groupsGoToQuery).
+    // Callers pass a typed variant class instance and we pattern-match on it.
     if (hasGroups && hasBodyMethod) {
       for (const group of op.parameterGroups ?? []) {
         const prop = fieldName(group.name);
         if (group.optional) {
           lines.push(`      if ${prop}`);
-          lines.push(`        case ${prop}[:type]`);
+          lines.push(`        case ${prop}`);
         } else {
-          lines.push(`      case ${prop}[:type]`);
+          lines.push(`      case ${prop}`);
         }
         for (const variant of group.variants) {
-          lines.push(`      when ${rubyStringLit(variant.name)}`);
+          const variantClass = variantClassRef(group, variant.name);
+          lines.push(`      when ${variantClass}`);
           for (const p of variant.parameters) {
-            lines.push(`        body[${rubyStringLit(p.name)}] = ${prop}[:${fieldName(p.name)}]`);
+            lines.push(`        body[${rubyStringLit(p.name)}] = ${prop}.${fieldName(p.name)}`);
           }
         }
+        lines.push(`      else`);
+        lines.push(`        raise ArgumentError, ${dispatchErrorLiteral(group, prop, variantClassRef)}`);
         lines.push('      end');
         if (group.optional) {
           lines.push('      end');
@@ -719,8 +793,9 @@ function buildYardDoc(
   queryParams: Parameter[],
   bodyFields: { name: string; required: boolean; type: TypeRef; description?: string; deprecated?: boolean }[],
   hiddenParams: Set<string>,
-  bodyFieldRenames?: Map<string, string>,
-  listWrapperModels?: Map<string, Model>,
+  bodyFieldRenames: Map<string, string> | undefined,
+  listWrapperModels: Map<string, Model> | undefined,
+  variantClassRef: (group: { name: string }, variantName: string) => string,
 ): string[] {
   const lines: string[] = [];
   const summary = op.description ?? `${op.httpMethod.toUpperCase()} ${op.path}`;
@@ -764,6 +839,16 @@ function buildYardDoc(
     const deprecatedPrefix = q.deprecated ? '(deprecated) ' : '';
     lines.push(`# @param ${n} [${type}${suffix}] ${deprecatedPrefix}${oneLine(q.description)}`.trim());
   }
+  // Parameter group kwargs: the type bracket lists the variant classes the
+  // caller may pass; no extra prose needed since YARD already renders them.
+  for (const group of op.parameterGroups ?? []) {
+    const n = fieldName(group.name);
+    if (emittedParamNames.has(n)) continue;
+    emittedParamNames.add(n);
+    const variantTypes = group.variants.map((v) => variantClassRef(group, v.name)).join(', ');
+    const suffix = group.optional ? ', nil' : '';
+    lines.push(`# @param ${n} [${variantTypes}${suffix}] Identifies the ${group.name.replace(/_/g, ' ')}.`);
+  }
   lines.push(`# @param request_options [Hash] (see WorkOS::Types::RequestOptions)`);
 
   // Return type: void for unknown-primitive, ListStruct for list wrappers and
@@ -797,3 +882,17 @@ void methodName;
 function rubyStringLit(s: string): string {
   return `'${s.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
 }
+
+/**
+ * Build a Ruby double-quoted string expression for the `else raise ArgumentError`
+ * arm of a parameter-group dispatcher. Lists the expected variant classes and
+ * interpolates the actual class of the value the caller passed.
+ */
+function dispatchErrorLiteral(
+  group: { name: string; variants: { name: string }[] },
+  prop: string,
+  variantClassRef: (group: { name: string }, variantName: string) => string,
+): string {
+  const expected = group.variants.map((v) => variantClassRef(group, v.name)).join(', ');
+  return `"expected ${prop} to be one of: ${expected}, got #{${prop}.class}"`;
+}

package/src/ruby/tests.ts

@@ -1,8 +1,23 @@
 import type { ApiSpec, EmitterContext, GeneratedFile, Model, Operation, ResolvedWrapper, TypeRef } from '@workos/oagen';
-import { className, fileName, fieldName, safeParamName, servicePropertyName, resolveMethodName } from './naming.js';
-import { buildResolvedLookup, groupByMount, lookupResolved, buildHiddenParams } from '../shared/resolved-ops.js';
+import {
+  className,
+  fileName,
+  fieldName,
+  safeParamName,
+  scopedGroupVariantClassName,
+  servicePropertyName,
+  resolveMethodName,
+} from './naming.js';
+import {
+  buildResolvedLookup,
+  groupByMount,
+  lookupResolved,
+  buildHiddenParams,
+  collectBodyFieldTypes,
+} from '../shared/resolved-ops.js';
 import { isListWrapperModel, isListMetadataModel } from '../shared/model-utils.js';
 import { resolveWrapperParams } from '../shared/wrapper-utils.js';
+import { buildGroupOwnerMap, pickVariantParamType } from './parameter-groups.js';
 
 /**
  * Generate Ruby Minitest test files for each service and per-method.
@@ -17,10 +32,12 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   const files: GeneratedFile[] = [];
 
   const groups = groupByMount(ctx);
+  const models = spec.models as Model[];
   const modelByName = new Map<string, Model>();
-  for (const m of spec.models as Model[]) modelByName.set(m.name, m);
+  for (const m of models) modelByName.set(m.name, m);
 
   const lookup = buildResolvedLookup(ctx);
+  const groupOwners = buildGroupOwnerMap(ctx);
 
   for (const [mountTarget, group] of groups) {
     const cls = className(mountTarget);
@@ -68,31 +85,63 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
 
       const resolved = lookupResolved(op, lookup);
       const hiddenParams = buildHiddenParams(resolved);
-      const callArgs = buildCallArgsStub(op, modelByName, hiddenParams);
+      const callArgs = buildCallArgsStub(op, modelByName, hiddenParams, groupOwners, models);
+      const bodyMatcher = buildBodyMatcher(op, modelByName, hiddenParams, models);
 
       // Collect method info for the parameterized 401 test (T20).
       authMethodManifest.push({ method, httpMethodSym, stubUrl, callArgs });
 
       const stubRegex = stubUrlRegex(stubUrl);
       lines.push(`  def test_${method}_returns_expected_result`);
+      lines.push(`    stub_request(${httpMethodSym}, ${stubRegex})`);
+      if (bodyMatcher) lines.push(`      .with(body: ${bodyMatcher})`);
       if (isList) {
-        lines.push(`    stub_request(${httpMethodSym}, ${stubRegex})`);
         lines.push(`      .to_return(body: '{"data": [], "list_metadata": {}}', status: 200)`);
         lines.push(`    result = @client.${prop}.${method}(${callArgs})`);
         lines.push('    assert_kind_of WorkOS::Types::ListStruct, result');
       } else if (op.response.kind === 'primitive') {
-        lines.push(`    stub_request(${httpMethodSym}, ${stubRegex})`);
         lines.push(`      .to_return(body: "{}", status: 200)`);
         lines.push(`    result = @client.${prop}.${method}(${callArgs})`);
         lines.push('    assert_nil result');
       } else {
-        lines.push(`    stub_request(${httpMethodSym}, ${stubRegex})`);
         lines.push(`      .to_return(body: "{}", status: 200)`);
         lines.push(`    result = @client.${prop}.${method}(${callArgs})`);
         lines.push('    refute_nil result');
       }
       lines.push('  end');
 
+      // Per-variant tests: for every parameter group with more than one
+      // variant, emit one extra test per non-first variant so the second/third
+      // arm of the dispatcher gets exercised. Without this, a wrong wire-name
+      // mapping in (e.g.) ResourceTargetByExternalId would slip through.
+      for (const group of op.parameterGroups ?? []) {
+        for (let vi = 1; vi < group.variants.length; vi++) {
+          const variant = group.variants[vi];
+          const overrides = new Map<string, number>([[group.name, vi]]);
+          const variantCallArgs = buildCallArgsStub(op, modelByName, hiddenParams, groupOwners, models, overrides);
+          const variantBodyMatcher = buildBodyMatcher(op, modelByName, hiddenParams, models, overrides);
+          const suffix = `with_${fieldName(group.name)}_${fieldName(variant.name)}`;
+          lines.push('');
+          lines.push(`  def test_${method}_${suffix}_returns_expected_result`);
+          lines.push(`    stub_request(${httpMethodSym}, ${stubRegex})`);
+          if (variantBodyMatcher) lines.push(`      .with(body: ${variantBodyMatcher})`);
+          if (isList) {
+            lines.push(`      .to_return(body: '{"data": [], "list_metadata": {}}', status: 200)`);
+            lines.push(`    result = @client.${prop}.${method}(${variantCallArgs})`);
+            lines.push('    assert_kind_of WorkOS::Types::ListStruct, result');
+          } else if (op.response.kind === 'primitive') {
+            lines.push(`      .to_return(body: "{}", status: 200)`);
+            lines.push(`    result = @client.${prop}.${method}(${variantCallArgs})`);
+            lines.push('    assert_nil result');
+          } else {
+            lines.push(`      .to_return(body: "{}", status: 200)`);
+            lines.push(`    result = @client.${prop}.${method}(${variantCallArgs})`);
+            lines.push('    refute_nil result');
+          }
+          lines.push('  end');
+        }
+      }
+
       // Wrapper tests (union split variants).
       if (resolved?.wrappers && resolved.wrappers.length > 0) {
         for (const wrapper of resolved.wrappers) {
@@ -278,8 +327,19 @@ function roundTripStub(ref: TypeRef, enumNames: Set<string>): string {
   }
 }
 
-/** Build minimal placeholder arguments for calling the SDK method from a test. */
-function buildCallArgsStub(op: Operation, modelByName: Map<string, Model>, hiddenParams: Set<string>): string {
+/** Build minimal placeholder arguments for calling the SDK method from a test.
+ *  `variantOverrides` selects a non-zero variant index per group; absent groups
+ *  default to variant 0. Used to emit per-variant test cases that exercise the
+ *  second/third arm of each parameter-group dispatcher.
+ */
+function buildCallArgsStub(
+  op: Operation,
+  modelByName: Map<string, Model>,
+  hiddenParams: Set<string>,
+  groupOwners: Map<string, string>,
+  models: Model[],
+  variantOverrides: Map<string, number> = new Map(),
+): string {
   const parts: string[] = [];
   const seen = new Set<string>();
 
@@ -323,24 +383,104 @@ function buildCallArgsStub(op: Operation, modelByName: Map<string, Model>, hidde
     parts.push(`${name}: ${stubValueFor(q.type)}`);
   }
 
-  // Required parameter group kwargs.
+  // Parameter group kwargs (required and optional): instantiate the first
+  // variant's class. Optional groups are exercised too so the dispatcher
+  // code path is covered — passing nothing would skip the body block and
+  // hide silent-drop bugs (see workos/oagen-emitters#66).
+  //
+  // Variant param types are recovered from the body model: the IR's leaf type
+  // is often a bare primitive (`role_slugs: string`) even when the body model
+  // declares a richer shape (`Array<String>`). Stubbing without recovery would
+  // pass `"stub"` to `RoleMultiple.new(role_slugs:)` while the class signature
+  // declares `T::Array[String]` — the test passes locally but ships an invalid
+  // wire body the API rejects.
+  const bodyFieldTypes = collectBodyFieldTypes(op, models);
   for (const group of op.parameterGroups ?? []) {
-    if (group.optional) continue;
     const name = fieldName(group.name);
     if (seen.has(name)) continue;
     seen.add(name);
-    // Stub as a hash with the first variant's type discriminant.
-    const firstVariant = group.variants[0];
-    if (firstVariant) {
-      parts.push(`${name}: { type: "${firstVariant.name}" }`);
-    } else {
-      parts.push(`${name}: {}`);
+    const idx = variantOverrides.get(group.name) ?? 0;
+    const variant = group.variants[idx];
+    if (variant) {
+      const owner = groupOwners.get(group.name);
+      if (!owner) {
+        throw new Error(`No owner mount target found for parameter group '${group.name}'`);
+      }
+      const variantClass = scopedGroupVariantClassName(owner, group.name, variant.name);
+      const fieldStubs = variant.parameters
+        .map((p) => `${fieldName(p.name)}: ${stubValueFor(pickVariantParamType(p.type, bodyFieldTypes.get(p.name)))}`)
+        .join(', ');
+      parts.push(`${name}: ${variantClass}.new(${fieldStubs})`);
     }
   }
 
   return parts.join(', ');
 }
 
+/**
+ * Build a Ruby `hash_including(...)` matcher describing the wire body the
+ * SDK should send for an operation whose body is constructed (in part) by a
+ * parameter-group dispatcher. Returns `null` for operations without body
+ * groups — those are still stubbed without a body matcher.
+ *
+ * The matcher includes every required non-group body field plus the first
+ * variant's wire-name leaves for each group dispatched into the body. This
+ * catches regressions where the dispatcher silently drops a passed group
+ * (the original `update_organization_membership` regression).
+ */
+function buildBodyMatcher(
+  op: Operation,
+  modelByName: Map<string, Model>,
+  hiddenParams: Set<string>,
+  models: Model[],
+  variantOverrides: Map<string, number> = new Map(),
+): string | null {
+  const httpMethod = op.httpMethod.toLowerCase();
+  const hasBodyMethod = !['get', 'head', 'delete'].includes(httpMethod);
+  const hasGroups = (op.parameterGroups?.length ?? 0) > 0;
+  if (!hasBodyMethod || !hasGroups) return null;
+
+  const groupedParamNames = new Set<string>();
+  for (const group of op.parameterGroups ?? []) {
+    for (const variant of group.variants) {
+      for (const p of variant.parameters) groupedParamNames.add(p.name);
+    }
+  }
+
+  const entries: string[] = [];
+
+  // Required non-group body fields, keyed by wire name.
+  if (op.requestBody) {
+    const bodyModel = resolveBodyModel(op.requestBody, modelByName);
+    if (bodyModel) {
+      for (const f of bodyModel.fields) {
+        if (!f.required) continue;
+        if (hiddenParams.has(f.name)) continue;
+        if (groupedParamNames.has(f.name)) continue;
+        entries.push(`"${f.name}" => ${stubValueFor(f.type)}`);
+      }
+    }
+  }
+
+  // Selected variant of each group: its leaves get pumped into the body. The
+  // matcher value must use the recovered (body-model) type, not the IR leaf —
+  // see buildCallArgsStub for the same reasoning. Without this, the matcher
+  // shape diverges from what the SDK actually sends.
+  const bodyFieldTypes = collectBodyFieldTypes(op, models);
+  for (const group of op.parameterGroups ?? []) {
+    const idx = variantOverrides.get(group.name) ?? 0;
+    const variant = group.variants[idx];
+    if (!variant) continue;
+    for (const p of variant.parameters) {
+      const recovered = pickVariantParamType(p.type, bodyFieldTypes.get(p.name));
+      entries.push(`"${p.name}" => ${stubValueFor(recovered)}`);
+    }
+  }
+
+  if (entries.length === 0) return null;
+  return `hash_including(${entries.join(', ')})`;
+}
+
 function resolveBodyModel(ref: TypeRef, modelByName: Map<string, Model>): Model | null {
   if (ref.kind === 'model') return modelByName.get(ref.name) ?? null;
   if (ref.kind === 'nullable') return resolveBodyModel(ref.inner, modelByName);
@@ -417,7 +557,10 @@ function stubValueFor(ref: TypeRef): string {
           return `nil`;
       }
     case 'array':
-      return `[]`;
+      // Single-element array — exercises the wire shape under hash_including
+      // matchers. An empty `[]` would match `"role_slugs": []` on the wire,
+      // hiding regressions where the SDK serializes the wrong type.
+      return `[${stubValueFor(ref.items)}]`;
     case 'map':
       return `{}`;
     case 'enum':

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');
+  });
 });