@contractkit/plugin-typescript 0.20.0 → 0.22.0

package/tests/codegen-operation.test.ts

@@ -807,9 +807,9 @@ describe('generateOp — route modifiers JSDoc', () => {
             expect(out).toContain('anonymous access, no security required');
         });
 
-        it('emits no annotation for security with roles', () => {
+        it('emits no annotation for security with requireMfa', () => {
             const op = opOperation('get', {
-                security: { roles: ['admin'], loc: { file: 'test.op', line: 1 } },
+                security: { requireMfa: true, loc: { file: 'test.op', line: 1 } },
             });
             const root = opRoot([opRoute('/users', [op])]);
             const out = generateOp(root);
@@ -867,7 +867,7 @@ describe('generateOp — route modifiers JSDoc', () => {
 
         it('does not import requireSignature when no signature is set', () => {
             const op = opOperation('get', {
-                security: { roles: ['admin'], loc: { file: 'test.op', line: 1 } },
+                security: { requireMfa: true, loc: { file: 'test.op', line: 1 } },
             });
             const root = opRoot([opRoute('/users', [op])]);
             const out = generateOp(root);
@@ -876,7 +876,7 @@ describe('generateOp — route modifiers JSDoc', () => {
         });
     });
 
-    // ─── Security (roles) middleware ────────────────────────────────
+    // ─── Security (requireMfa) middleware ───────────────────────────
 
     describe('security middleware', () => {
         it('injects requireSecurity() with no args for unannotated routes', () => {
@@ -884,27 +884,26 @@ describe('generateOp — route modifiers JSDoc', () => {
             const root = opRoot([opRoute('/users', [op])]);
             const out = generateOp(root);
             expect(out).toContain(`import { ServerKitRouter, bodyParserMiddleware, requireSecurity }`);
-            expect(out).toContain(`requireSecurity({  })`);
+            expect(out).toContain(`requireSecurity()`);
         });
 
-        it('injects requireSecurity with roles when roles are set', () => {
+        it('injects requireSecurity with requireMfa: true when set', () => {
             const op = opOperation('get', {
-                security: { roles: ['admin'], loc: { file: 'test.op', line: 1 } },
+                security: { requireMfa: true, loc: { file: 'test.op', line: 1 } },
             });
             const root = opRoot([opRoute('/users', [op])]);
             const out = generateOp(root);
-            expect(out).toContain(`requireSecurity({ roles: ['admin'] })`);
+            expect(out).toContain(`requireSecurity({ requireMfa: true })`);
         });
 
-        it('passes multiple roles as an array', () => {
+        it('injects requireSecurity with requireMfa: false when set', () => {
             const op = opOperation('get', {
-                security: { roles: ['admin', 'support'], loc: { file: 'test.op', line: 1 } },
+                security: { requireMfa: false, loc: { file: 'test.op', line: 1 } },
             });
-            const root = opRoot([opRoute('/users', [op])]);
-            const routeLine = generateOp(root)
+            const routeLine = generateOp(opRoot([opRoute('/users', [op])]))
                 .split('\n')
                 .find(l => l.includes('.get('));
-            expect(routeLine).toContain(`requireSecurity({ roles: ['admin', 'support'] })`);
+            expect(routeLine).toContain(`requireSecurity({ requireMfa: false })`);
         });
 
         it('does not inject requireSecurity for public (security: none) routes', () => {
@@ -924,7 +923,7 @@ describe('generateOp — route modifiers JSDoc', () => {
 
         it('places requireSecurity before bodyParserMiddleware in the route line', () => {
             const op = opOperation('post', {
-                security: { roles: ['admin'], loc: { file: 'test.op', line: 1 } },
+                security: { requireMfa: true, loc: { file: 'test.op', line: 1 } },
                 request: opRequest('Payload'),
             });
             const root = opRoot([opRoute('/users', [op])]);
@@ -941,7 +940,7 @@ describe('generateOp — route modifiers JSDoc', () => {
         it('places requireSecurity before requireSignature when both are set', () => {
             const op = opOperation('post', {
                 signature: 'MY_KEY',
-                security: { roles: ['admin'], loc: { file: 'test.op', line: 1 } },
+                security: { requireMfa: true, loc: { file: 'test.op', line: 1 } },
                 request: opRequest('Payload'),
             });
             const root = opRoot([opRoute('/webhooks', [op])]);
@@ -958,7 +957,7 @@ describe('generateOp — route modifiers JSDoc', () => {
         it('imports both requireSecurity and requireSignature when both are set', () => {
             const op = opOperation('post', {
                 signature: 'MY_KEY',
-                security: { roles: ['admin'], loc: { file: 'test.op', line: 1 } },
+                security: { requireMfa: true, loc: { file: 'test.op', line: 1 } },
                 request: opRequest('Payload'),
             });
             const root = opRoot([opRoute('/webhooks', [op])]);
@@ -966,13 +965,13 @@ describe('generateOp — route modifiers JSDoc', () => {
             expect(out).toContain(`import { ServerKitRouter, bodyParserMiddleware, requireSecurity, requireSignature }`);
         });
 
-        it('works with route-level roles security', () => {
+        it('works with route-level requireMfa security', () => {
             const op = opOperation('get');
             const route = opRoute('/users', [op]);
-            route.security = { roles: ['admin'], loc: { file: 'test.op', line: 1 } };
+            route.security = { requireMfa: true, loc: { file: 'test.op', line: 1 } };
             const root = opRoot([route]);
             const out = generateOp(root);
-            expect(out).toContain(`requireSecurity({ roles: ['admin'] })`);
+            expect(out).toContain(`requireSecurity({ requireMfa: true })`);
         });
     });
 });

package/tests/codegen-sdk.test.ts

@@ -3,6 +3,7 @@ import {
     generateSdk,
     generateSdkOptions,
     generateSdkAggregator,
+    generateAreaClient,
     deriveClientClassName,
     deriveClientPropertyName,
     deriveAreaClientClassName,
@@ -1536,60 +1537,83 @@ describe('area + subarea name derivation', () => {
 // ─── generateSdkAggregator — area + subarea wiring ────────────────────────
 
 describe('generateSdkAggregator — area + subarea', () => {
-    it('emits one <Area>Client per area with subarea property wiring', () => {
+    it('imports each area client and exposes it on Sdk', () => {
         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' },
-                        },
-                    ],
+                    client: { className: 'IdentityClient', propertyName: 'identity', importPath: './identity/identity.client.js' },
+                },
+            ],
+        });
+        expect(out).toContain("import { IdentityClient } from './identity/identity.client.js'");
+        expect(out).toContain('export class Sdk {');
+        expect(out).toContain('readonly identity: IdentityClient');
+        expect(out).toContain('this.identity = new IdentityClient(sdkFetch)');
+        // The aggregator no longer declares the IdentityClient itself.
+        expect(out).not.toContain('class IdentityClient {');
+    });
+
+    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',
+                    client: { className: 'PaymentsClient', propertyName: 'payments', importPath: './payments/payments.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 payments: PaymentsClient');
+        expect(out).toContain('readonly webhooks: WebhooksClient');
+        expect(out).toContain('this.payments = new PaymentsClient(sdkFetch)');
+        expect(out).toContain('this.webhooks = new WebhooksClient(sdkFetch)');
+    });
+});
+
+describe('generateAreaClient — <Area>Client emission', () => {
+    it('emits one <Area>Client class with subarea property wiring', () => {
+        const out = generateAreaClient({
+            area: 'identity',
+            outPath: '/out/identity/identity.client.ts',
+            inlineFiles: [],
+            subareaClients: [
+                {
+                    propertyName: 'invitations',
+                    client: { className: 'IdentityInvitationsClient', propertyName: 'invitations', importPath: './invitations.client.js' },
+                },
+                {
+                    propertyName: 'users',
+                    client: { className: 'IdentityUsersClient', propertyName: 'users', importPath: './users.client.js' },
+                },
+            ],
+            sdkOptionsPath: '/out/sdk-options.ts',
+        });
+        expect(out).toContain("import { IdentityInvitationsClient } from './invitations.client.js'");
+        expect(out).toContain("import { IdentityUsersClient } from './users.client.js'");
+        expect(out).toContain('export 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', () => {
+    it('inlines methods from area-level (no-subarea) files into the 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: [],
-                },
-            ],
+        const out = generateAreaClient({
+            area: 'identity',
+            outPath: '/out/identity/identity.client.ts',
+            inlineFiles: [{ root, codegenOptions: { outPath: '/out/identity/identity.client.ts', sdkOptionsPath: '/out/sdk-options.ts' } }],
+            subareaClients: [],
+            sdkOptionsPath: '/out/sdk-options.ts',
         });
-        expect(out).toContain('class IdentityClient {');
+        expect(out).toContain('export 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)');
     });
 
@@ -1599,20 +1623,17 @@ describe('generateSdkAggregator — area + subarea', () => {
             'identity.ck',
             { area: 'identity' },
         );
-        const out = generateSdkAggregator({
-            topLevelClients: [],
-            areas: [
+        const out = generateAreaClient({
+            area: 'identity',
+            outPath: '/out/identity/identity.client.ts',
+            inlineFiles: [{ root: inlineRoot, codegenOptions: { outPath: '/out/identity/identity.client.ts', sdkOptionsPath: '/out/sdk-options.ts' } }],
+            subareaClients: [
                 {
-                    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' },
-                        },
-                    ],
+                    propertyName: 'invitations',
+                    client: { className: 'IdentityInvitationsClient', propertyName: 'invitations', importPath: './invitations.client.js' },
                 },
             ],
+            sdkOptionsPath: '/out/sdk-options.ts',
         });
         expect(out).toContain('readonly invitations: IdentityInvitationsClient');
         expect(out).toContain('async getCurrentUser(');
@@ -1631,42 +1652,16 @@ describe('generateSdkAggregator — area + subarea', () => {
             { 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: [],
-                    },
+            generateAreaClient({
+                area: 'identity',
+                outPath: '/out/identity/identity.client.ts',
+                inlineFiles: [
+                    { root: a, codegenOptions: { outPath: '/out/identity/identity.client.ts', sdkOptionsPath: '/out/sdk-options.ts' } },
+                    { root: b, codegenOptions: { outPath: '/out/identity/identity.client.ts', sdkOptionsPath: '/out/sdk-options.ts' } },
                 ],
+                subareaClients: [],
+                sdkOptionsPath: '/out/sdk-options.ts',
             }),
         ).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

@@ -204,7 +204,7 @@ describe('createTypescriptPlugin (sdk) — area / subarea grouping', () => {
         return undefined;
     }
 
-    it('emits a leaf <Area><Subarea>Client and nests it under <Area>Client in sdk.ts', async () => {
+    it('emits a leaf <Area><Subarea>Client and a separate <Area>Client wrapper file', async () => {
         const plugin = createTypescriptPlugin({ sdk: { output: { sdk: 'sdk.ts', clients: '{area}/{subarea}.client.ts' } } }, '/project');
         const ctx = makeCtx('/project');
         const root = opRoot(
@@ -220,18 +220,25 @@ describe('createTypescriptPlugin (sdk) — area / subarea grouping', () => {
         expect(leaf!).toContain('export class IdentityInvitationsClient');
         expect(leaf!).toContain('async createInvitation');
 
-        // Aggregator declares IdentityClient + Sdk wiring
+        // Separate <area>.client.ts holds the IdentityClient wrapper
+        const areaClient = findEmitted(ctx.emitted, 'identity/identity.client.ts');
+        expect(areaClient).toBeDefined();
+        expect(areaClient!).toContain('export class IdentityClient {');
+        expect(areaClient!).toContain('readonly invitations: IdentityInvitationsClient');
+        expect(areaClient!).toContain('this.invitations = new IdentityInvitationsClient(fetch)');
+
+        // sdk.ts just imports + wires the area client onto Sdk
         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("import { IdentityClient } from './identity/identity.client.js'");
         expect(sdk!).toContain('export class Sdk {');
         expect(sdk!).toContain('readonly identity: IdentityClient');
         expect(sdk!).toContain('this.identity = new IdentityClient(sdkFetch)');
+        // The class declaration itself is no longer in sdk.ts.
+        expect(sdk!).not.toContain('class IdentityClient {');
     });
 
-    it('does NOT emit a standalone client file for an area-level (no-subarea) input — methods inline into sdk.ts', async () => {
+    it('emits a synthesized <area>.client.ts for area-level (no-subarea) inputs instead of inlining 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(
@@ -241,19 +248,24 @@ describe('createTypescriptPlugin (sdk) — area / subarea grouping', () => {
         );
         await plugin.generateTargets!(inputs([root]), ctx);
 
-        // No per-file leaf for the area-level input
+        // The contributing file does NOT get its own *.client.ts (per the previous design).
         for (const path of ctx.emitted.keys()) {
             expect(path).not.toMatch(/identity[/-]me\.client\.ts$/);
         }
 
-        // Methods land directly on IdentityClient inside sdk.ts
+        // The area client lives in <area>/<area>.client.ts and holds the merged methods.
+        const areaClient = findEmitted(ctx.emitted, 'identity/identity.client.ts');
+        expect(areaClient).toBeDefined();
+        expect(areaClient!).toContain('export class IdentityClient {');
+        expect(areaClient!).toContain('async getCurrentUser');
+
+        // sdk.ts just imports it.
         const sdk = findEmitted(ctx.emitted, '/sdk.ts');
-        expect(sdk).toBeDefined();
-        expect(sdk!).toContain('class IdentityClient {');
-        expect(sdk!).toContain('async getCurrentUser');
+        expect(sdk!).toContain("import { IdentityClient } from './identity/identity.client.js'");
+        expect(sdk!).not.toContain('class IdentityClient {');
     });
 
-    it('mixes area-level inline methods with subarea property wiring on the same area client', async () => {
+    it('mixes area-level inline methods with subarea property wiring on the same <area>.client.ts', async () => {
         const plugin = createTypescriptPlugin({ sdk: { output: { sdk: 'sdk.ts', clients: '{area}/{filename}.client.ts' } } }, '/project');
         const ctx = makeCtx('/project');
         const me = opRoot(
@@ -268,10 +280,10 @@ describe('createTypescriptPlugin (sdk) — area / subarea grouping', () => {
         );
         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');
+        const areaClient = findEmitted(ctx.emitted, 'identity/identity.client.ts')!;
+        expect(areaClient).toContain('export class IdentityClient {');
+        expect(areaClient).toContain('readonly invitations: IdentityInvitationsClient');
+        expect(areaClient).toContain('async getCurrentUser');
     });
 
     it('preserves legacy flat wiring for files with no area', async () => {