@contractkit/plugin-typescript 0.17.5 → 0.19.0

package/tests/codegen-sdk.test.ts

@@ -5,6 +5,11 @@ import {
     generateSdkAggregator,
     deriveClientClassName,
     deriveClientPropertyName,
+    deriveAreaClientClassName,
+    deriveAreaPropertyName,
+    deriveSubareaClientClassName,
+    deriveSubareaPropertyName,
+    getAreaSubarea,
     hasPublicOperations,
 } from '../src/codegen-sdk.js';
 import { collectPublicTypeNames } from '@contractkit/core';
@@ -762,11 +767,14 @@ describe('generateSdkOptions', () => {
 });
 
 describe('generateSdkAggregator', () => {
-    it('generates Sdk class wrapping all clients', () => {
-        const out = generateSdkAggregator([
-            { className: 'UsersClient', propertyName: 'users', importPath: './src/users.client.js' },
-            { className: 'CategoriesClient', propertyName: 'categories', importPath: './src/categories.client.js' },
-        ]);
+    it('generates Sdk class wrapping all top-level clients', () => {
+        const out = generateSdkAggregator({
+            topLevelClients: [
+                { className: 'UsersClient', propertyName: 'users', importPath: './src/users.client.js' },
+                { className: 'CategoriesClient', propertyName: 'categories', importPath: './src/categories.client.js' },
+            ],
+            areas: [],
+        });
         expect(out).toContain("import type { SdkOptions } from './sdk-options.js'");
         expect(out).toContain("import { createSdkFetch } from './sdk-options.js'");
         expect(out).toContain("import { UsersClient } from './src/users.client.js'");
@@ -781,10 +789,11 @@ describe('generateSdkAggregator', () => {
     });
 
     it('uses custom sdkOptionsImportPath', () => {
-        const out = generateSdkAggregator(
-            [{ className: 'UsersClient', propertyName: 'users', importPath: './users.client.js' }],
-            '../shared/sdk-options.js',
-        );
+        const out = generateSdkAggregator({
+            topLevelClients: [{ className: 'UsersClient', propertyName: 'users', importPath: './users.client.js' }],
+            areas: [],
+            sdkOptionsImportPath: '../shared/sdk-options.js',
+        });
         expect(out).toContain("from '../shared/sdk-options.js'");
     });
 });
@@ -1401,17 +1410,17 @@ describe('generateSdk — type import paths', () => {
 
 describe('generateSdkAggregator — additional cases', () => {
     it('uses custom sdkClassName', () => {
-        const out = generateSdkAggregator(
-            [{ className: 'UsersClient', propertyName: 'users', importPath: './users.client.js' }],
-            './sdk-options.js',
-            'ApiClient',
-        );
+        const out = generateSdkAggregator({
+            topLevelClients: [{ className: 'UsersClient', propertyName: 'users', importPath: './users.client.js' }],
+            areas: [],
+            sdkClassName: 'ApiClient',
+        });
         expect(out).toContain('export class ApiClient {');
         expect(out).not.toContain('export class Sdk {');
     });
 
-    it('handles empty clients array', () => {
-        const out = generateSdkAggregator([]);
+    it('handles empty input', () => {
+        const out = generateSdkAggregator({ topLevelClients: [], areas: [] });
         expect(out).toContain('export class Sdk {');
         expect(out).toContain('constructor(options: SdkOptions)');
         expect(out).not.toContain('readonly ');
@@ -1498,3 +1507,166 @@ describe('generateSdk — json type in query / headers / params', () => {
         expect(out).toContain('export type JsonValue =');
     });
 });
+
+// ─── Area / subarea name derivation ───────────────────────────────────────
+
+describe('area + subarea name derivation', () => {
+    it('builds area client class and property names', () => {
+        expect(deriveAreaClientClassName('identity')).toBe('IdentityClient');
+        expect(deriveAreaPropertyName('identity')).toBe('identity');
+        expect(deriveAreaClientClassName('payment-flows')).toBe('PaymentFlowsClient');
+        expect(deriveAreaPropertyName('payment-flows')).toBe('paymentFlows');
+    });
+
+    it('builds subarea (concatenated) client class and property names', () => {
+        expect(deriveSubareaClientClassName('identity', 'invitations')).toBe('IdentityInvitationsClient');
+        expect(deriveSubareaPropertyName('invitations')).toBe('invitations');
+        expect(deriveSubareaClientClassName('payments', 'gift-cards')).toBe('PaymentsGiftCardsClient');
+        expect(deriveSubareaPropertyName('gift-cards')).toBe('giftCards');
+    });
+
+    it('reads area and subarea from root.meta', () => {
+        const root = opRoot([], 'x.ck', { area: 'identity', subarea: 'invitations' });
+        expect(getAreaSubarea(root)).toEqual({ area: 'identity', subarea: 'invitations' });
+        const noKeys = opRoot([], 'x.ck');
+        expect(getAreaSubarea(noKeys)).toEqual({ area: undefined, subarea: undefined });
+    });
+});
+
+// ─── generateSdkAggregator — area + subarea wiring ────────────────────────
+
+describe('generateSdkAggregator — area + subarea', () => {
+    it('emits one <Area>Client per area with subarea property wiring', () => {
+        const out = generateSdkAggregator({
+            topLevelClients: [],
+            areas: [
+                {
+                    area: 'identity',
+                    inlineFiles: [],
+                    subareaClients: [
+                        {
+                            propertyName: 'invitations',
+                            client: { className: 'IdentityInvitationsClient', propertyName: 'invitations', importPath: './identity/invitations.client.js' },
+                        },
+                        {
+                            propertyName: 'users',
+                            client: { className: 'IdentityUsersClient', propertyName: 'users', importPath: './identity/users.client.js' },
+                        },
+                    ],
+                },
+            ],
+        });
+        expect(out).toContain("import { IdentityInvitationsClient } from './identity/invitations.client.js'");
+        expect(out).toContain("import { IdentityUsersClient } from './identity/users.client.js'");
+        expect(out).toContain('class IdentityClient {');
+        expect(out).toContain('readonly invitations: IdentityInvitationsClient');
+        expect(out).toContain('readonly users: IdentityUsersClient');
+        expect(out).toContain('this.invitations = new IdentityInvitationsClient(fetch)');
+        expect(out).toContain('this.users = new IdentityUsersClient(fetch)');
+        // Sdk wires the area property
+        expect(out).toContain('export class Sdk {');
+        expect(out).toContain('readonly identity: IdentityClient');
+        expect(out).toContain('this.identity = new IdentityClient(sdkFetch)');
+    });
+
+    it('inlines methods from area-level (no-subarea) files into <Area>Client', () => {
+        const root = opRoot(
+            [opRoute('/me', [opOperation('get', { sdk: 'getCurrentUser', responses: [opResponse(200, 'User', 'application/json')] })])],
+            'identity.ck',
+            { area: 'identity' },
+        );
+        const out = generateSdkAggregator({
+            topLevelClients: [],
+            areas: [
+                {
+                    area: 'identity',
+                    inlineFiles: [{ root, codegenOptions: { outPath: '/out/sdk.ts', sdkOptionsPath: '/out/sdk-options.ts' } }],
+                    subareaClients: [],
+                },
+            ],
+        });
+        expect(out).toContain('class IdentityClient {');
+        expect(out).toContain('async getCurrentUser(');
+        // No subarea property declarations on this client
+        expect(out).not.toMatch(/readonly \w+: \w+;[\s\S]*async getCurrentUser/);
+        // The fetch arg is captured as `private fetch` since methods reference `this.fetch`
+        expect(out).toContain('constructor(private fetch: SdkFetch)');
+    });
+
+    it('mixes inline area methods with subarea property wiring on the same area client', () => {
+        const inlineRoot = opRoot(
+            [opRoute('/me', [opOperation('get', { sdk: 'getCurrentUser', responses: [opResponse(200, 'User', 'application/json')] })])],
+            'identity.ck',
+            { area: 'identity' },
+        );
+        const out = generateSdkAggregator({
+            topLevelClients: [],
+            areas: [
+                {
+                    area: 'identity',
+                    inlineFiles: [{ root: inlineRoot, codegenOptions: { outPath: '/out/sdk.ts', sdkOptionsPath: '/out/sdk-options.ts' } }],
+                    subareaClients: [
+                        {
+                            propertyName: 'invitations',
+                            client: { className: 'IdentityInvitationsClient', propertyName: 'invitations', importPath: './identity/invitations.client.js' },
+                        },
+                    ],
+                },
+            ],
+        });
+        expect(out).toContain('readonly invitations: IdentityInvitationsClient');
+        expect(out).toContain('async getCurrentUser(');
+        expect(out).toContain('this.invitations = new IdentityInvitationsClient(fetch)');
+    });
+
+    it('throws on duplicate method names across area-level files in the same area', () => {
+        const a = opRoot(
+            [opRoute('/me', [opOperation('get', { sdk: 'getCurrentUser', responses: [opResponse(200, 'User', 'application/json')] })])],
+            'a.ck',
+            { area: 'identity' },
+        );
+        const b = opRoot(
+            [opRoute('/whoami', [opOperation('get', { sdk: 'getCurrentUser', responses: [opResponse(200, 'User', 'application/json')] })])],
+            'b.ck',
+            { area: 'identity' },
+        );
+        expect(() =>
+            generateSdkAggregator({
+                topLevelClients: [],
+                areas: [
+                    {
+                        area: 'identity',
+                        inlineFiles: [
+                            { root: a, codegenOptions: { outPath: '/out/sdk.ts', sdkOptionsPath: '/out/sdk-options.ts' } },
+                            { root: b, codegenOptions: { outPath: '/out/sdk.ts', sdkOptionsPath: '/out/sdk-options.ts' } },
+                        ],
+                        subareaClients: [],
+                    },
+                ],
+            }),
+        ).toThrow(/duplicate method 'getCurrentUser' in area 'identity'/);
+    });
+
+    it('mixes area clients with top-level (no-area) clients', () => {
+        const out = generateSdkAggregator({
+            topLevelClients: [{ className: 'WebhooksClient', propertyName: 'webhooks', importPath: './webhooks.client.js' }],
+            areas: [
+                {
+                    area: 'payments',
+                    inlineFiles: [],
+                    subareaClients: [
+                        {
+                            propertyName: 'transfers',
+                            client: { className: 'PaymentsTransfersClient', propertyName: 'transfers', importPath: './payments/transfers.client.js' },
+                        },
+                    ],
+                },
+            ],
+        });
+        // Sdk has both an area property AND a top-level property
+        expect(out).toContain('readonly payments: PaymentsClient');
+        expect(out).toContain('readonly webhooks: WebhooksClient');
+        expect(out).toContain('this.payments = new PaymentsClient(sdkFetch)');
+        expect(out).toContain('this.webhooks = new WebhooksClient(sdkFetch)');
+    });
+});

package/tests/codegen-server.test.ts

@@ -10,6 +10,7 @@ function makeCtx(rootDir = '/project', options: Record<string, unknown> = {}): P
     return {
         rootDir,
         options,
+        cacheEnabled: true,
         emitFile: (outPath: string, content: string) => {
             emitted.set(outPath, content);
         },
@@ -63,7 +64,8 @@ describe('createTypescriptPlugin (server)', () => {
                 ]),
                 ctx,
             );
-            expect(ctx.emitted.size).toBe(2);
+            const routeFiles = [...ctx.emitted.keys()].filter(p => p.endsWith('.router.ts'));
+            expect(routeFiles.length).toBe(2);
         });
 
         it('emits type files alongside routes when output.types is configured', async () => {
@@ -190,3 +192,101 @@ describe('createTypescriptPlugin (server)', () => {
         });
     });
 });
+
+// ─── SDK pipeline: area / subarea grouping ─────────────────────────────────
+
+describe('createTypescriptPlugin (sdk) — area / subarea grouping', () => {
+    function findEmitted(emitted: Map<string, string>, suffix: string): string | undefined {
+        for (const [path, content] of emitted) {
+            if (path.endsWith(suffix)) return content;
+        }
+        return undefined;
+    }
+
+    it('emits a leaf <Area><Subarea>Client and nests it under <Area>Client in sdk.ts', async () => {
+        const plugin = createTypescriptPlugin({ sdk: { output: { sdk: 'sdk.ts', clients: '{area}/{subarea}.client.ts' } } }, '/project');
+        const ctx = makeCtx('/project');
+        const root = opRoot(
+            [opRoute('/identity/invitations', [opOperation('post', { sdk: 'createInvitation', responses: [opResponse(201)] })])],
+            '/project/contracts/identity-invitations.ck',
+            { area: 'identity', subarea: 'invitations' },
+        );
+        await plugin.generateTargets!(inputs([root]), ctx);
+
+        // Leaf client emitted at the {area}/{subarea}.client.ts path
+        const leaf = findEmitted(ctx.emitted, 'identity/invitations.client.ts');
+        expect(leaf).toBeDefined();
+        expect(leaf!).toContain('export class IdentityInvitationsClient');
+        expect(leaf!).toContain('async createInvitation');
+
+        // Aggregator declares IdentityClient + Sdk wiring
+        const sdk = findEmitted(ctx.emitted, '/sdk.ts');
+        expect(sdk).toBeDefined();
+        expect(sdk!).toContain('class IdentityClient {');
+        expect(sdk!).toContain('readonly invitations: IdentityInvitationsClient');
+        expect(sdk!).toContain('this.invitations = new IdentityInvitationsClient(fetch)');
+        expect(sdk!).toContain('export class Sdk {');
+        expect(sdk!).toContain('readonly identity: IdentityClient');
+        expect(sdk!).toContain('this.identity = new IdentityClient(sdkFetch)');
+    });
+
+    it('does NOT emit a standalone client file for an area-level (no-subarea) input — methods inline into sdk.ts', async () => {
+        const plugin = createTypescriptPlugin({ sdk: { output: { sdk: 'sdk.ts', clients: '{area}/{filename}.client.ts' } } }, '/project');
+        const ctx = makeCtx('/project');
+        const root = opRoot(
+            [opRoute('/me', [opOperation('get', { sdk: 'getCurrentUser', responses: [opResponse(200)] })])],
+            '/project/contracts/identity-me.ck',
+            { area: 'identity' },
+        );
+        await plugin.generateTargets!(inputs([root]), ctx);
+
+        // No per-file leaf for the area-level input
+        for (const path of ctx.emitted.keys()) {
+            expect(path).not.toMatch(/identity[/-]me\.client\.ts$/);
+        }
+
+        // Methods land directly on IdentityClient inside sdk.ts
+        const sdk = findEmitted(ctx.emitted, '/sdk.ts');
+        expect(sdk).toBeDefined();
+        expect(sdk!).toContain('class IdentityClient {');
+        expect(sdk!).toContain('async getCurrentUser');
+    });
+
+    it('mixes area-level inline methods with subarea property wiring on the same area client', async () => {
+        const plugin = createTypescriptPlugin({ sdk: { output: { sdk: 'sdk.ts', clients: '{area}/{filename}.client.ts' } } }, '/project');
+        const ctx = makeCtx('/project');
+        const me = opRoot(
+            [opRoute('/me', [opOperation('get', { sdk: 'getCurrentUser', responses: [opResponse(200)] })])],
+            '/project/contracts/identity-me.ck',
+            { area: 'identity' },
+        );
+        const invitations = opRoot(
+            [opRoute('/identity/invitations', [opOperation('post', { sdk: 'createInvitation', responses: [opResponse(201)] })])],
+            '/project/contracts/identity-invitations.ck',
+            { area: 'identity', subarea: 'invitations' },
+        );
+        await plugin.generateTargets!(inputs([me, invitations]), ctx);
+
+        const sdk = findEmitted(ctx.emitted, '/sdk.ts')!;
+        expect(sdk).toContain('class IdentityClient {');
+        expect(sdk).toContain('readonly invitations: IdentityInvitationsClient');
+        expect(sdk).toContain('async getCurrentUser');
+    });
+
+    it('preserves legacy flat wiring for files with no area', async () => {
+        const plugin = createTypescriptPlugin({ sdk: { output: { sdk: 'sdk.ts', clients: '{filename}.client.ts' } } }, '/project');
+        const ctx = makeCtx('/project');
+        const root = opRoot(
+            [opRoute('/webhooks', [opOperation('post', { sdk: 'sendWebhook', responses: [opResponse(202)] })])],
+            '/project/contracts/webhooks.ck',
+        );
+        await plugin.generateTargets!(inputs([root]), ctx);
+
+        const sdk = findEmitted(ctx.emitted, '/sdk.ts')!;
+        // No <Area>Client wrapper; flat property on Sdk
+        expect(sdk).toContain('export class Sdk {');
+        expect(sdk).toContain('readonly webhooks: WebhooksClient');
+        expect(sdk).toContain('this.webhooks = new WebhooksClient(sdkFetch)');
+        expect(sdk).not.toMatch(/class \w+Client \{/m);
+    });
+});