@workos/oagen-emitters 0.18.4 → 0.19.1

package/test/ruby/tests.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect } from 'vitest';
+import type { EmitterContext, ApiSpec, Service, Model, ResolvedOperation } from '@workos/oagen';
+import { defaultSdkBehavior, toSnakeCase, toPascalCase, assignModelsToServices } from '@workos/oagen';
+import { generateTests } from '../../src/ruby/tests.js';
+import { fileName, buildMountDirMap } from '../../src/ruby/naming.js';
+import { classifyUnassignedModel } from '../../src/ruby/models.js';
+
+function makeSpec(services: Service[], models: Model[]): ApiSpec {
+  return {
+    name: 'Test',
+    version: '1.0.0',
+    baseUrl: 'https://api.workos.com',
+    services,
+    models,
+    enums: [],
+    sdk: defaultSdkBehavior(),
+  };
+}
+
+function buildResolvedOps(services: Service[]): ResolvedOperation[] {
+  const ops: ResolvedOperation[] = [];
+  for (const service of services) {
+    const mountOn = toPascalCase(service.name);
+    for (const op of service.operations) {
+      ops.push({
+        operation: op,
+        service,
+        methodName: toSnakeCase(op.name),
+        mountOn,
+        defaults: {},
+        inferFromClient: [],
+        urlBuilder: false,
+      });
+    }
+  }
+  return ops;
+}
+
+/** Compute the per-model `.rb` path exactly as ruby/models.ts (and tests.ts) does. */
+function modelFilePath(modelName: string, spec: ApiSpec, ctx: EmitterContext): string {
+  const modelToService = assignModelsToServices(spec.models as Model[], spec.services, ctx.modelHints);
+  const mountDirMap = buildMountDirMap(ctx);
+  const service = modelToService.get(modelName);
+  const dir = service
+    ? (mountDirMap.get(service) ?? classifyUnassignedModel(modelName))
+    : classifyUnassignedModel(modelName);
+  return `lib/workos/${dir}/${fileName(modelName)}.rb`;
+}
+
+const models: Model[] = [
+  // In-scope: selected service's model.
+  { name: 'Organization', fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }] },
+  // On-disk: out-of-scope this run, but its file is recorded in the prior manifest.
+  { name: 'Connection', fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }] },
+  // Brand-new out-of-scope: out-of-scope AND not in the prior manifest.
+  { name: 'Directory', fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }] },
+];
+
+const services: Service[] = [
+  {
+    name: 'Organizations',
+    operations: [
+      {
+        name: 'listOrganizations',
+        httpMethod: 'get',
+        path: '/organizations',
+        pathParams: [],
+        queryParams: [],
+        headerParams: [],
+        response: { kind: 'model', name: 'Organization' },
+        errors: [],
+        injectIdempotencyKey: false,
+      },
+    ],
+  },
+];
+
+const spec = makeSpec(services, models);
+
+function findRoundTripFile(files: { path: string; content: string }[]): { path: string; content: string } {
+  const file = files.find((f) => f.path === 'test/workos/test_model_round_trip.rb');
+  if (!file) throw new Error('round-trip test file not emitted');
+  return file;
+}
+
+describe('ruby/tests model round-trip aggregate scoping', () => {
+  it('full run: round-trips every model', () => {
+    const ctx: EmitterContext = {
+      namespace: 'workos',
+      namespacePascal: 'WorkOS',
+      spec,
+      resolvedOperations: buildResolvedOps(services),
+    };
+    const content = findRoundTripFile(generateTests(spec, ctx)).content;
+    expect(content).toContain('WorkOS::Organization.new');
+    expect(content).toContain('WorkOS::Connection.new');
+    expect(content).toContain('WorkOS::Directory.new');
+  });
+
+  it('scoped run: keeps in-scope + on-disk models, drops brand-new out-of-scope models', () => {
+    const onDiskPath = modelFilePath('Connection', spec, {
+      namespace: 'workos',
+      namespacePascal: 'WorkOS',
+      spec,
+      resolvedOperations: buildResolvedOps(services),
+    });
+
+    const ctx: EmitterContext = {
+      namespace: 'workos',
+      namespacePascal: 'WorkOS',
+      spec,
+      resolvedOperations: buildResolvedOps(services),
+      // Scoped to the Organizations service / Organization model only.
+      scopedServices: new Set(['Organizations']),
+      scopedModelNames: new Set(['Organization']),
+      // Connection's per-model file already exists on disk from a prior run.
+      priorTargetManifestPaths: new Set([onDiskPath]),
+    };
+
+    const content = findRoundTripFile(generateTests(spec, ctx)).content;
+
+    // In-scope model: kept.
+    expect(content).toContain('WorkOS::Organization.new');
+    // On-disk (prior manifest) model: retained even though out-of-scope.
+    expect(content).toContain('WorkOS::Connection.new');
+    // Brand-new out-of-scope model: NO round-trip test (would NameError).
+    expect(content).not.toContain('WorkOS::Directory.new');
+    expect(content).not.toContain('def test_directory_round_trip');
+  });
+});

package/test/rust/fixtures.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import type { ApiSpec, Enum, Model } from '@workos/oagen';
+import type { ApiSpec, Enum, Model, EmitterContext } from '@workos/oagen';
 import { defaultSdkBehavior } from '@workos/oagen';
 import { exampleFromSpec, generateFixtures, generateModelFixture } from '../../src/rust/fixtures.js';
 
@@ -15,6 +15,12 @@ function spec(models: Model[], enums: Enum[] = []): ApiSpec {
   };
 }
 
+// Minimal full-run context (no `scopedServices`): scoping is inert, so every
+// fixture is emitted — matching these tests' intent of asserting content.
+function ctx(s: ApiSpec): EmitterContext {
+  return { namespace: 'test', namespacePascal: 'Test', spec: s };
+}
+
 describe('rust/fixtures', () => {
   it('prefers a spec `example` over the generated placeholder for a primitive field', () => {
     const models: Model[] = [
@@ -36,7 +42,7 @@ describe('rust/fixtures', () => {
         ],
       },
     ];
-    const files = generateFixtures(spec(models));
+    const files = generateFixtures(spec(models), ctx(spec(models)));
     const file = files.find((f) => f.path === 'tests/fixtures/event.json')!;
     expect(file).toBeDefined();
     const parsed = JSON.parse(file.content);
@@ -59,7 +65,7 @@ describe('rust/fixtures', () => {
         ],
       },
     ];
-    const files = generateFixtures(spec(models));
+    const files = generateFixtures(spec(models), ctx(spec(models)));
     const file = files.find((f) => f.path === 'tests/fixtures/wrong.json')!;
     const parsed = JSON.parse(file.content);
     expect(parsed.count).toBe(0); // placeholder fallback
@@ -82,7 +88,7 @@ describe('rust/fixtures', () => {
         ],
       },
     ];
-    const files = generateFixtures(spec(models));
+    const files = generateFixtures(spec(models), ctx(spec(models)));
     const file = files.find((f) => f.path === 'tests/fixtures/org.json')!;
     const parsed = JSON.parse(file.content);
     expect(parsed.domains).toEqual(['example.com', 'foo.com']);
@@ -120,7 +126,7 @@ describe('rust/fixtures', () => {
         ],
       },
     ];
-    const files = generateFixtures(spec(models));
+    const files = generateFixtures(spec(models), ctx(spec(models)));
     const file = files.find((f) => f.path === 'tests/fixtures/outer.json')!;
     const parsed = JSON.parse(file.content);
     // The nested model is regenerated from its own fields' examples, not from
@@ -162,7 +168,7 @@ describe('rust/fixtures', () => {
         ],
       },
     ];
-    const files = generateFixtures(spec(models, enums));
+    const files = generateFixtures(spec(models, enums), ctx(spec(models, enums)));
     const good = JSON.parse(files.find((f) => f.path === 'tests/fixtures/good_ex.json')!.content);
     const bad = JSON.parse(files.find((f) => f.path === 'tests/fixtures/bad_ex.json')!.content);
     expect(good.status).toBe('pending'); // valid example wins
@@ -183,7 +189,7 @@ describe('rust/fixtures', () => {
         ],
       },
     ];
-    const files = generateFixtures(spec(models));
+    const files = generateFixtures(spec(models), ctx(spec(models)));
     const parsed = JSON.parse(files.find((f) => f.path === 'tests/fixtures/nullish.json')!.content);
     expect(parsed.name).toBe('test_name');
   });

package/test/shared/synthetic-enum-seed.test.ts

@@ -0,0 +1,79 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type { Enum, Model } from '@workos/oagen';
+import { enrichModelsFromSpec, getSyntheticEnums } from '../../src/shared/model-utils.js';
+
+// Regression: an inline oneOf enum whose synthetic name (`Parent_field`)
+// snake-collapses onto an existing IR enum must NOT spawn a duplicate
+// synthetic. `DataIntegrationAccessTokenResponse.error` (-> synthetic
+// `DataIntegrationAccessTokenResponse_error`) and the parser-emitted IR enum
+// `DataIntegrationAccessTokenResponseError` both snake to
+// `data_integration_access_token_response_error`. When both exist, every
+// PascalCase-normalizing emitter (PHP, Ruby, Go, ...) collapses them onto the
+// SAME file path, and which one wins is decided by array order — which differs
+// between a full and a scoped (`--services`) generation, yielding a
+// non-deterministic enum-case order. Seeding `enrichModelsFromSpec` with the
+// IR enum names suppresses the duplicate so the real enum always wins.
+const SPEC = {
+  openapi: '3.0.0',
+  info: { title: 'fixture', version: '1.0.0' },
+  paths: {},
+  components: {
+    schemas: {
+      DataIntegrationAccessTokenResponse: {
+        oneOf: [
+          {
+            type: 'object',
+            properties: {
+              error: {
+                type: 'string',
+                enum: ['not_installed', 'needs_reauthorization'],
+              },
+            },
+          },
+        ],
+      },
+    },
+  },
+};
+
+const SYNTHETIC_NAME = 'DataIntegrationAccessTokenResponse_error';
+const models: Model[] = [{ name: 'DataIntegrationAccessTokenResponse', fields: [] }];
+const collidingEnum: Enum = {
+  name: 'DataIntegrationAccessTokenResponseError',
+  values: [
+    { name: 'NOT_INSTALLED', value: 'not_installed' },
+    { name: 'NEEDS_REAUTHORIZATION', value: 'needs_reauthorization' },
+  ],
+};
+
+let dir: string;
+
+beforeAll(() => {
+  dir = mkdtempSync(join(tmpdir(), 'synthetic-enum-seed-'));
+  const specPath = join(dir, 'spec.yaml');
+  // `loadRawSpec` accepts JSON too (js-yaml parses JSON), so write JSON.
+  writeFileSync(specPath, JSON.stringify(SPEC));
+  process.env.OPENAPI_SPEC_PATH = specPath;
+});
+
+afterAll(() => {
+  delete process.env.OPENAPI_SPEC_PATH;
+  if (dir) rmSync(dir, { recursive: true, force: true });
+});
+
+describe('enrichModelsFromSpec — synthetic enum seed', () => {
+  it('emits the inline synthetic enum when no IR enum names are seeded', () => {
+    enrichModelsFromSpec(models);
+    const names = getSyntheticEnums().map((e) => e.name);
+    expect(names).toContain(SYNTHETIC_NAME);
+  });
+
+  it('suppresses the duplicate synthetic when the colliding IR enum is seeded', () => {
+    enrichModelsFromSpec(models, [collidingEnum]);
+    const names = getSyntheticEnums().map((e) => e.name);
+    expect(names).not.toContain(SYNTHETIC_NAME);
+  });
+});