@workos/oagen-emitters 0.3.0 → 0.5.0

package/test/node/resources.test.ts

@@ -99,16 +99,98 @@ describe('generateResources', () => {
     const files = generateResources(services, ctx);
     const content = files[0].content;
 
-    // Should have AutoPaginatable type import and createPaginatedList import
-    expect(content).toContain("import type { AutoPaginatable } from '../common/utils/pagination'");
-    expect(content).toContain("import { createPaginatedList } from '../common/utils/fetch-and-deserialize'");
+    // Should have AutoPaginatable value import and fetchAndDeserialize import
+    expect(content).toContain("import { AutoPaginatable } from '../common/utils/pagination'");
+    expect(content).toContain("import { fetchAndDeserialize } from '../common/utils/fetch-and-deserialize'");
+    // Options interface lives in its own file under interfaces/ so the
+    // per-service barrel picks it up.
+    expect(content).toContain(
+      "import type { ListOrganizationsOptions } from './interfaces/list-organizations-options.interface';",
+    );
 
-    // Should generate options interface
-    expect(content).toContain('export interface ListOrganizationsOptions extends PaginationOptions {');
-    expect(content).toContain('domains?: string[];');
+    // The options interface file is emitted separately.
+    const optionsFile = files.find(
+      (f) => f.path === 'src/organizations/interfaces/list-organizations-options.interface.ts',
+    );
+    expect(optionsFile).toBeDefined();
+    expect(optionsFile!.content).toContain('export interface ListOrganizationsOptions extends PaginationOptions {');
+    expect(optionsFile!.content).toContain('domains?: string[];');
 
     // Should return AutoPaginatable
     expect(content).toContain('Promise<AutoPaginatable<Organization, ListOrganizationsOptions>>');
+
+    // `domains` has the same camelCase and snake_case spelling, so no wire
+    // serializer should be emitted; options are passed directly.
+    expect(content).not.toContain('serializeListOrganizationsOptions');
+    expect(content).toContain('new AutoPaginatable(');
+    expect(content).toContain('fetchAndDeserialize<OrganizationResponse, Organization>');
+    expect(content).toContain('options,');
+  });
+
+  it('emits wire-options serializer for paginated list with camelCase filter fields', () => {
+    // Regression test for PR #1535 reviewer comment r3075477146: list
+    // methods whose extended filter fields have divergent camelCase/snake_case
+    // spellings (e.g. `organizationId` ↔ `organization_id`) must translate
+    // keys before hitting the wire, otherwise the API silently ignores them.
+    const services: Service[] = [
+      {
+        name: 'Applications',
+        operations: [
+          {
+            name: 'listApplications',
+            httpMethod: 'get',
+            path: '/connect/applications',
+            pathParams: [],
+            queryParams: [
+              {
+                name: 'organization_id',
+                type: { kind: 'primitive', type: 'string' },
+                required: false,
+                description: 'Filter by organization ID.',
+              },
+            ],
+            headerParams: [],
+            response: { kind: 'model', name: 'ConnectApplication' },
+            errors: [],
+            pagination: {
+              strategy: 'cursor',
+              param: 'after',
+              dataPath: 'data',
+              itemType: { kind: 'model', name: 'ConnectApplication' },
+            },
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+
+    const files = generateResources(services, ctx);
+    const content = files[0].content;
+
+    // Options interface uses camelCase (user-facing) and lives in its own file.
+    const optionsFile = files.find(
+      (f) => f.path === 'src/applications/interfaces/list-applications-options.interface.ts',
+    );
+    expect(optionsFile).toBeDefined();
+    expect(optionsFile!.content).toContain('export interface ListApplicationsOptions extends PaginationOptions {');
+    expect(optionsFile!.content).toContain('organizationId?: string;');
+
+    // Resource class imports the options type from the interface file.
+    expect(content).toContain(
+      "import type { ListApplicationsOptions } from './interfaces/list-applications-options.interface';",
+    );
+
+    // Wire-options serializer emits snake_case key for the extension field
+    // and leaves standard pagination fields unchanged.
+    expect(content).toContain(
+      'const serializeListApplicationsOptions = (options: ListApplicationsOptions): PaginationOptions => {',
+    );
+    expect(content).toContain('wire.organization_id = options.organizationId');
+    expect(content).not.toContain('wire.organizationId');
+
+    // fetchAndDeserialize is invoked with the serialized options.
+    expect(content).toContain('serializeListApplicationsOptions(options)');
+    expect(content).toContain('new AutoPaginatable(');
   });
 
   it('uses item type not list wrapper type for paginated methods', () => {
@@ -150,7 +232,7 @@ describe('generateResources', () => {
     const content = files[0].content;
 
     // Should use item type (Connection) not list wrapper (ConnectionList)
-    expect(content).toContain('createPaginatedList<ConnectionResponse, Connection,');
+    expect(content).toContain('fetchAndDeserialize<ConnectionResponse, Connection>');
     expect(content).toContain('deserializeConnection');
     expect(content).toContain('Promise<AutoPaginatable<Connection,');
 
@@ -191,6 +273,47 @@ describe('generateResources', () => {
     expect(content).toContain('await this.workos.delete(');
   });
 
+  it('generates unpaginated GET returning an array of models', () => {
+    // Regression test for PR #1535 reviewer comment (r3074705330): endpoints
+    // whose OpenAPI response is `type: array` must return `Model[]` and map
+    // the deserializer over each element, not treat the array as a single
+    // object (which silently produces garbage at runtime).
+    const services: Service[] = [
+      {
+        name: 'Secrets',
+        operations: [
+          {
+            name: 'listSecrets',
+            httpMethod: 'get',
+            path: '/applications/{id}/secrets',
+            pathParams: [
+              {
+                name: 'id',
+                type: { kind: 'primitive', type: 'string' },
+                required: true,
+              },
+            ],
+            queryParams: [],
+            headerParams: [],
+            response: { kind: 'array', items: { kind: 'model', name: 'Secret' } },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+
+    const files = generateResources(services, ctx);
+    const content = files[0].content;
+
+    expect(content).toContain('async listSecrets(id: string): Promise<Secret[]>');
+    expect(content).toContain('this.workos.get<SecretResponse[]>');
+    expect(content).toContain('return data.map(deserializeSecret);');
+    // Should NOT produce the single-object form — that was the bug.
+    expect(content).not.toMatch(/Promise<Secret>\s*\{/);
+    expect(content).not.toContain('return deserializeSecret(data);');
+  });
+
   it('generates POST method with body and idempotency', () => {
     const services: Service[] = [
       {
@@ -891,14 +1014,20 @@ describe('generateResources', () => {
     // Should use the union type for the payload parameter
     expect(content).toContain('payload: AuthByPassword | AuthByCode | AuthByMagicAuth');
 
-    // Should dispatch to the correct serializer based on the discriminator
-    expect(content).toContain('switch ((payload as any).grantType)');
-    expect(content).toContain("case 'password': return serializeAuthByPassword(payload as any)");
-    expect(content).toContain("case 'authorization_code': return serializeAuthByCode(payload as any)");
+    // Should dispatch to the correct serializer based on the discriminator,
+    // using the typed discriminator so TS narrows payload per case.
+    expect(content).toContain('switch (payload.grantType)');
+    expect(content).toContain("case 'password': return serializeAuthByPassword(payload)");
+    expect(content).toContain("case 'authorization_code': return serializeAuthByCode(payload)");
     expect(content).toContain(
-      "case 'urn:workos:oauth:grant-type:magic-auth:code': return serializeAuthByMagicAuth(payload as any)",
+      "case 'urn:workos:oauth:grant-type:magic-auth:code': return serializeAuthByMagicAuth(payload)",
     );
 
+    // Should not use `as any` casts — TS discriminated-union narrowing makes
+    // them unnecessary and they suppress real type mismatches.
+    expect(content).not.toContain('switch ((payload as any)');
+    expect(content).not.toMatch(/return serialize\w+\(payload as any\)/);
+
     // Should import serializers for all union variants
     expect(content).toContain('serializeAuthByPassword');
     expect(content).toContain('serializeAuthByCode');
@@ -906,6 +1035,13 @@ describe('generateResources', () => {
 
     // Should NOT pass payload directly without serialization
     expect(content).not.toMatch(/,\n\s+payload,\n/);
+
+    // Default branch must throw — silently forwarding unserialized camelCase
+    // to the API produces malformed requests when the discriminator is unknown.
+    expect(content).toContain('default:');
+    expect(content).toContain('const _unknown: never = payload');
+    expect(content).toContain('throw new Error');
+    expect(content).not.toMatch(/default:\s*return payload/);
   });
 
   it('generates discriminated union serializer dispatch for void method', () => {
@@ -945,13 +1081,13 @@ describe('generateResources', () => {
     const files = generateResources(services, ctx);
     const content = files[0].content;
 
-    // Should dispatch to the correct serializer
-    expect(content).toContain('switch ((payload as any).grantType)');
-    expect(content).toContain("case 'authorization_code': return serializeTokenByCode(payload as any)");
-    expect(content).toContain("case 'refresh_token': return serializeTokenByRefresh(payload as any)");
+    // Should dispatch to the correct serializer using the typed discriminator.
+    expect(content).toContain('switch (payload.grantType)');
+    expect(content).toContain("case 'authorization_code': return serializeTokenByCode(payload)");
+    expect(content).toContain("case 'refresh_token': return serializeTokenByRefresh(payload)");
   });
 
-  it('uses createPaginatedList helper in paginated methods', () => {
+  it('uses AutoPaginatable pattern in paginated methods', () => {
     const services: Service[] = [
       {
         name: 'Connections',
@@ -980,9 +1116,9 @@ describe('generateResources', () => {
     const files = generateResources(services, ctx);
     const content = files[0].content;
 
-    // Should use createPaginatedList helper for concise paginated methods
-    expect(content).toContain('createPaginatedList<ConnectionResponse, Connection,');
-    expect(content).toContain('this.workos,');
+    // Should use AutoPaginatable + fetchAndDeserialize pattern for paginated methods
+    expect(content).toContain('new AutoPaginatable(');
+    expect(content).toContain('fetchAndDeserialize<ConnectionResponse, Connection>');
     expect(content).toContain('deserializeConnection');
   });
 
@@ -1048,10 +1184,13 @@ describe('generateResources', () => {
     const content = files[0].content;
 
     // Should use service-prefixed options name instead of generic "ListOptions"
-    expect(content).toContain('export interface PaymentsListOptions extends PaginationOptions {');
+    const optionsFile = files.find((f) => f.path.endsWith('payments-list-options.interface.ts'));
+    expect(optionsFile).toBeDefined();
+    expect(optionsFile!.content).toContain('export interface PaymentsListOptions extends PaginationOptions {');
     expect(content).toContain('Promise<AutoPaginatable<Connection, PaymentsListOptions>>');
     // Should NOT use the generic "ListOptions"
     expect(content).not.toContain('export interface ListOptions ');
+    expect(files.every((f) => !f.path.endsWith('/list-options.interface.ts'))).toBe(true);
   });
 
   it('does not prefix ListOptions when method is not "list"', () => {
@@ -1090,10 +1229,11 @@ describe('generateResources', () => {
     ];
 
     const files = generateResources(services, ctx);
-    const content = files[0].content;
 
     // Method is "listOrganizations", not "list", so options name should be normal
-    expect(content).toContain('export interface ListOrganizationsOptions extends PaginationOptions {');
+    const optionsFile = files.find((f) => f.path.endsWith('list-organizations-options.interface.ts'));
+    expect(optionsFile).toBeDefined();
+    expect(optionsFile!.content).toContain('export interface ListOrganizationsOptions extends PaginationOptions {');
   });
 
   it('removes skipIfExists when fully-covered service has methods absent from baseline', () => {
@@ -1268,11 +1408,72 @@ describe('generateResources', () => {
       },
     };
 
+    const files = generateResources(services, overlayCtx);
+    // Fully covered services with no new methods are skipped entirely
+    expect(files.length).toBe(0);
+  });
+
+  it('removes skipIfExists for purely oagen-managed services (no baseline)', () => {
+    const services: Service[] = [
+      {
+        name: 'Applications',
+        operations: [
+          {
+            name: 'create',
+            httpMethod: 'post',
+            path: '/connect/applications',
+            pathParams: [],
+            queryParams: [],
+            headerParams: [],
+            response: { kind: 'model', name: 'ConnectApplication' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+
+    const overlayCtx: EmitterContext = {
+      namespace: 'workos',
+      namespacePascal: 'WorkOS',
+      spec: { ...emptySpec, services, models: [] },
+      overlayLookup: {
+        methodByOperation: new Map([
+          [
+            'POST /connect/applications',
+            {
+              className: 'Applications',
+              methodName: 'create',
+              params: [],
+              returnType: 'ConnectApplication',
+            },
+          ],
+        ]),
+        httpKeyByMethod: new Map(),
+        interfaceByName: new Map(),
+        typeAliasByName: new Map(),
+        requiredExports: new Map(),
+        modelNameByIR: new Map(),
+        fileBySymbol: new Map(),
+      },
+      apiSurface: {
+        language: 'node',
+        extractedFrom: 'test',
+        extractedAt: '2024-01-01',
+        // No baseline class for Applications — purely oagen-managed.
+        classes: {},
+        interfaces: {},
+        typeAliases: {},
+        enums: {},
+        exports: {},
+      },
+    };
+
     const files = generateResources(services, overlayCtx);
     expect(files.length).toBe(1);
 
-    // skipIfExists should stay true because all methods exist in baseline
-    expect(files[0].skipIfExists).toBe(true);
+    // skipIfExists must be removed so emitter improvements always overwrite.
+    expect(files[0].skipIfExists).toBeUndefined();
   });
 });
 
@@ -1647,7 +1848,7 @@ describe('partial service coverage', () => {
     expect(content).toContain('async createEvent');
   });
 
-  it('generates resource class for fully covered services to provide JSDoc', () => {
+  it('skips fully covered services with no new methods', () => {
     const services: Service[] = [
       {
         name: 'Permissions',
@@ -1719,14 +1920,9 @@ describe('partial service coverage', () => {
     };
 
     const files = generateResources(services, ctxCovered);
-    expect(files.length).toBe(1);
-    const content = files[0].content;
-    // All methods should have generated JSDoc — the merger matches by name
-    // and handles @deprecated preservation, so the emitter always provides
-    // docstrings for the merger to work with.
-    expect(content).toContain('List all permissions.');
-    // skipIfExists should remain true for covered services
-    expect(files[0].skipIfExists).toBe(true);
+    // Fully covered services with no new methods are skipped entirely
+    // (JSDoc-only updates are deferred until a structural change touches the file)
+    expect(files.length).toBe(0);
   });
 
   it('uses resolved operation method names when provided', () => {
@@ -1846,4 +2042,117 @@ describe('partial service coverage', () => {
     const createMethods = methodNames.filter((n) => n.toLowerCase().startsWith('create'));
     expect(new Set(createMethods).size).toBe(createMethods.length); // all unique
   });
+
+  it('omits @param payload when overlay method has no payload param', () => {
+    const services: Service[] = [
+      {
+        name: 'AuditLogs',
+        operations: [
+          {
+            name: 'createEvent',
+            httpMethod: 'post',
+            path: '/audit_logs/events',
+            pathParams: [],
+            queryParams: [],
+            headerParams: [],
+            requestBody: { kind: 'model', name: 'CreateAuditLogEvent' },
+            response: { kind: 'primitive', type: 'unknown' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+
+    const overlayCtx: EmitterContext = {
+      namespace: 'workos',
+      namespacePascal: 'WorkOS',
+      spec: { ...emptySpec, services, models: [] },
+      overlayLookup: {
+        methodByOperation: new Map([
+          [
+            'POST /audit_logs/events',
+            {
+              className: 'AuditLogs',
+              methodName: 'createEvent',
+              params: [
+                { name: 'organization', type: 'string', optional: false },
+                { name: 'event', type: 'CreateAuditLogEventOptions', optional: false },
+                { name: 'options', type: 'CreateAuditLogEventRequestOptions', optional: true },
+              ],
+              returnType: 'Promise<void>',
+            },
+          ],
+        ]),
+        httpKeyByMethod: new Map(),
+        interfaceByName: new Map(),
+        typeAliasByName: new Map(),
+        requiredExports: new Map(),
+        modelNameByIR: new Map(),
+        fileBySymbol: new Map(),
+      },
+    };
+
+    const files = generateResources(services, overlayCtx);
+    const content = files[0].content;
+    // Overlay has (organization, event, options) — no payload param
+    expect(content).not.toContain('@param payload');
+  });
+
+  it('documents @param options when overlay folds path params into options', () => {
+    const services: Service[] = [
+      {
+        name: 'FeatureFlags',
+        operations: [
+          {
+            name: 'addFeatureFlagTarget',
+            httpMethod: 'post',
+            path: '/feature-flags/{slug}/targets/{target_id}',
+            pathParams: [
+              { name: 'slug', type: { kind: 'primitive', type: 'string' }, required: true },
+              { name: 'target_id', type: { kind: 'primitive', type: 'string' }, required: true },
+            ],
+            queryParams: [],
+            headerParams: [],
+            response: { kind: 'primitive', type: 'unknown' },
+            errors: [],
+            injectIdempotencyKey: false,
+          },
+        ],
+      },
+    ];
+
+    const overlayCtx: EmitterContext = {
+      namespace: 'workos',
+      namespacePascal: 'WorkOS',
+      spec: { ...emptySpec, services, models: [] },
+      overlayLookup: {
+        methodByOperation: new Map([
+          [
+            'POST /feature-flags/{slug}/targets/{target_id}',
+            {
+              className: 'FeatureFlags',
+              methodName: 'addFlagTarget',
+              params: [{ name: 'options', type: 'AddFlagTargetOptions', optional: false }],
+              returnType: 'Promise<void>',
+            },
+          ],
+        ]),
+        httpKeyByMethod: new Map(),
+        interfaceByName: new Map(),
+        typeAliasByName: new Map(),
+        requiredExports: new Map(),
+        modelNameByIR: new Map(),
+        fileBySymbol: new Map(),
+      },
+    };
+
+    const files = generateResources(services, overlayCtx);
+    const content = files[0].content;
+    // Path params (slug, targetId) are folded into options — should not appear as top-level @param
+    expect(content).not.toContain('@param slug');
+    expect(content).not.toContain('@param targetId');
+    // Should have @param options since it's in the overlay signature
+    expect(content).toContain('@param options');
+  });
 });

package/test/node/utils.test.ts

@@ -0,0 +1,140 @@
+import { describe, it, expect } from 'vitest';
+import { modelHasNewFields } from '../../src/node/utils.js';
+import type { EmitterContext, ApiSpec, Model } from '@workos/oagen';
+import { defaultSdkBehavior } from '@workos/oagen';
+
+const emptySpec: ApiSpec = {
+  name: 'Test',
+  version: '1.0.0',
+  baseUrl: '',
+  services: [],
+  models: [],
+  enums: [],
+  sdk: defaultSdkBehavior(),
+};
+
+const ctx: EmitterContext = {
+  namespace: 'workos',
+  namespacePascal: 'WorkOS',
+  spec: emptySpec,
+};
+
+describe('modelHasNewFields', () => {
+  const model: Model = {
+    name: 'Organization',
+    fields: [
+      { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+      { name: 'name', type: { kind: 'primitive', type: 'string' }, required: true },
+    ],
+  };
+
+  it('returns true when no apiSurface exists (Scenario B)', () => {
+    expect(modelHasNewFields(model, ctx)).toBe(true);
+  });
+
+  it('returns true when model has no baseline entry (new model)', () => {
+    const ctxWithSurface: EmitterContext = {
+      ...ctx,
+      apiSurface: {
+        language: 'node',
+        extractedFrom: 'test',
+        extractedAt: '2024-01-01',
+        classes: {},
+        interfaces: {},
+        typeAliases: {},
+        enums: {},
+        exports: {},
+      },
+    };
+    expect(modelHasNewFields(model, ctxWithSurface)).toBe(true);
+  });
+
+  it('returns false when all fields exist in baseline', () => {
+    const ctxWithBaseline: EmitterContext = {
+      ...ctx,
+      apiSurface: {
+        language: 'node',
+        extractedFrom: 'test',
+        extractedAt: '2024-01-01',
+        classes: {},
+        typeAliases: {},
+        enums: {},
+        exports: {},
+        interfaces: {
+          Organization: {
+            name: 'Organization',
+            fields: {
+              id: { name: 'id', type: 'string', optional: false },
+              name: { name: 'name', type: 'string', optional: false },
+            },
+            extends: [],
+          },
+        },
+      },
+    };
+    expect(modelHasNewFields(model, ctxWithBaseline)).toBe(false);
+  });
+
+  it('returns true when model has one new field not in baseline', () => {
+    const modelWithNewField: Model = {
+      name: 'Organization',
+      fields: [
+        { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true },
+        { name: 'name', type: { kind: 'primitive', type: 'string' }, required: true },
+        { name: 'slug', type: { kind: 'primitive', type: 'string' }, required: false },
+      ],
+    };
+    const ctxWithBaseline: EmitterContext = {
+      ...ctx,
+      apiSurface: {
+        language: 'node',
+        extractedFrom: 'test',
+        extractedAt: '2024-01-01',
+        classes: {},
+        typeAliases: {},
+        enums: {},
+        exports: {},
+        interfaces: {
+          Organization: {
+            name: 'Organization',
+            fields: {
+              id: { name: 'id', type: 'string', optional: false },
+              name: { name: 'name', type: 'string', optional: false },
+            },
+            extends: [],
+          },
+        },
+      },
+    };
+    expect(modelHasNewFields(modelWithNewField, ctxWithBaseline)).toBe(true);
+  });
+
+  it('converts snake_case IR field names to camelCase for baseline comparison', () => {
+    const snakeModel: Model = {
+      name: 'Organization',
+      fields: [{ name: 'organization_id', type: { kind: 'primitive', type: 'string' }, required: true }],
+    };
+    const ctxWithBaseline: EmitterContext = {
+      ...ctx,
+      apiSurface: {
+        language: 'node',
+        extractedFrom: 'test',
+        extractedAt: '2024-01-01',
+        classes: {},
+        typeAliases: {},
+        enums: {},
+        exports: {},
+        interfaces: {
+          Organization: {
+            name: 'Organization',
+            fields: {
+              organizationId: { name: 'organizationId', type: 'string', optional: false },
+            },
+            extends: [],
+          },
+        },
+      },
+    };
+    expect(modelHasNewFields(snakeModel, ctxWithBaseline)).toBe(false);
+  });
+});

package/test/php/client.test.ts

@@ -74,8 +74,9 @@ describe('generateClient', () => {
     expect(result[0].content).toContain("string $baseUrl = 'https://api.example.com'");
     expect(result[0].content).toContain('int $timeout = 60');
     expect(result[0].content).toContain('int $maxRetries = 3');
+    expect(result[0].content).toContain('?string $userAgent = null');
     expect(result[0].content).toContain(
-      'new HttpClient($apiKey, $clientId, $baseUrl, $timeout, $maxRetries, $handler)',
+      'new HttpClient($apiKey, $clientId, $baseUrl, $timeout, $maxRetries, $handler, $userAgent)',
     );
     expect(result[0].content).not.toContain('self::$apiKey = $apiKey;');
     expect(result[0].content).not.toContain('self::$clientId = $clientId;');

package/test/php/models.test.ts

@@ -436,7 +436,7 @@ describe('generateModels', () => {
     expect(file!.content).not.toContain('instanceof \\BackedEnum');
   });
 
-  it('deduplicates structurally identical models', () => {
+  it('emits all structurally identical models as full classes', () => {
     const models: Model[] = [
       {
         name: 'FlagCreatedContextActor',
@@ -464,11 +464,12 @@ describe('generateModels', () => {
     const specWithModels = { ...emptySpec, models };
     const result = generateModels(models, { ...ctx, spec: specWithModels });
 
-    // Only the trait + one canonical model file should be emitted (not 3)
+    // PHP readonly classes cannot be aliased, so all models are emitted as full classes
     const modelFiles = result.filter((f) => !f.path.includes('Trait'));
-    expect(modelFiles).toHaveLength(1);
-    // Shortest class name wins as canonical
+    expect(modelFiles).toHaveLength(3);
     expect(modelFiles[0].path).toContain('FlagCreatedContextActor');
+    expect(modelFiles[1].path).toContain('FlagUpdatedContextActor');
+    expect(modelFiles[2].path).toContain('FlagDeletedContextActor');
   });
 
   it('does not produce double |null in @var for nullable optional arrays', () => {