@contractkit/plugin-typescript 0.31.2 → 0.33.0

package/tests/codegen-sdk.test.ts

@@ -1294,7 +1294,7 @@ describe('renderTsType', () => {
         });
 
         it('throws on an unmapped scalar name', () => {
-            expect(() => renderTsType({ kind: 'scalar', name: 'decimal' } as any)).toThrow(/unmapped scalar 'decimal'/);
+            expect(() => renderTsType({ kind: 'scalar', name: 'quaternion' } as any)).toThrow(/unmapped scalar 'quaternion'/);
         });
     });
 
@@ -1857,9 +1857,72 @@ describe('generateAreaClient — <Area>Client emission', () => {
     });
 });
 
+describe('decimal rehydration', () => {
+    const withDecimal = (extra: Partial<Parameters<typeof generateSdk>[1]> = {}) => ({
+        modelsWithDecimal: new Set(['Invoice']),
+        modelOutPaths: new Map([['Invoice', '/out/types/models.ts']]),
+        outPath: '/out/clients/inv.client.ts',
+        sdkOptionsPath: '/out/sdk-options.ts',
+        ...extra,
+    });
+
+    it('wraps a model-ref response body in its reviver', () => {
+        const root = opRoot([opRoute('/invoices/{id}', [opOperation('get', { responses: [opResponse(200, 'Invoice')] })])], 'inv.op');
+        const out = generateSdk(root, withDecimal());
+        expect(out).toContain('return reviveInvoice(await parseJson<Invoice>(result));');
+        // The reviver is a value, so it needs a second import beside the `import type`.
+        expect(out).toContain(`import { reviveInvoice } from '../types/models.js';`);
+    });
+
+    it('maps over an array body rather than emitting a wrapper', () => {
+        const root = opRoot([opRoute('/invoices', [opOperation('get', { responses: [opResponse(200, 'array(Invoice)')] })])], 'inv.op');
+        const out = generateSdk(root, withDecimal());
+        // Safe because the reviver returns the object it mutated.
+        expect(out).toContain('return (await parseJson<Invoice[]>(result)).map(reviveInvoice);');
+    });
+
+    it('emits a local wrapper for a body with no reviveX of its own', () => {
+        const bodyType = inlineObjectType([field('grand', scalarType('decimal', { scale: 2 }))]);
+        const root = opRoot([opRoute('/totals', [opOperation('get', { sdk: 'getTotals', responses: [opResponse(200, bodyType)] })])], 'tot.op');
+        const out = generateSdk(root, withDecimal({ modelsWithDecimal: new Set(['Invoice']) }));
+        expect(out).toMatch(/function __reviveGetTotals200\(/);
+        // The wrapper calls `__dec`, which is file-local to the types module, so the client file
+        // needs its own copy plus the decimal.js import and global config.
+        expect(out).toContain(`import { Decimal } from 'decimal.js';`);
+        expect(out).toContain('Decimal.set({ toExpNeg: -9e15, toExpPos: 9e15 });');
+        expect(out).toContain('const __dec = (v: unknown, path: string): Decimal =>');
+    });
+
+    it('picks the Output reviver when the model has an Output variant', () => {
+        const root = opRoot([opRoute('/invoices/{id}', [opOperation('get', { responses: [opResponse(200, 'Invoice')] })])], 'inv.op');
+        const out = generateSdk(root, withDecimal({ modelsWithOutput: new Set(['Invoice']) }));
+        expect(out).toContain('reviveInvoiceOutput(');
+    });
+
+    it('leaves a decimal-free SDK byte-identical', () => {
+        const root = opRoot([opRoute('/users', [opOperation('get', { responses: [opResponse(200, 'User')] })])], 'users.op');
+        const base = generateSdk(root, { modelOutPaths: new Map([['User', '/out/types/models.ts']]), outPath: '/out/clients/u.client.ts' });
+        const withEmptySet = generateSdk(root, {
+            modelOutPaths: new Map([['User', '/out/types/models.ts']]),
+            outPath: '/out/clients/u.client.ts',
+            modelsWithDecimal: new Set(),
+        });
+        expect(withEmptySet).toBe(base);
+        expect(base).not.toContain('revive');
+        expect(base).not.toContain('decimal.js');
+    });
+
+    it('does not revive a body whose model carries no decimal', () => {
+        const root = opRoot([opRoute('/users', [opOperation('get', { responses: [opResponse(200, 'User')] })])], 'users.op');
+        const out = generateSdk(root, withDecimal({ modelOutPaths: new Map([['User', '/out/types/models.ts']]) }));
+        expect(out).toContain('return await parseJson<User>(result);');
+        expect(out).not.toContain('revive');
+    });
+});
+
 describe('generateSdkPackageJson', () => {
     it('emits a valid package.json with the given name and standard fields', () => {
-        const pkg = JSON.parse(generateSdkPackageJson({ name: 'my-sdk', deps: { zod: false, luxon: false } }));
+        const pkg = JSON.parse(generateSdkPackageJson({ name: 'my-sdk', deps: { zod: false, luxon: false, decimal: false } }));
         expect(pkg.name).toBe('my-sdk');
         expect(pkg.type).toBe('module');
         expect(pkg.exports['.'].types).toBe('./dist/index.d.ts');
@@ -1868,25 +1931,33 @@ describe('generateSdkPackageJson', () => {
     });
 
     it('omits the dependencies block entirely when neither zod nor luxon is used', () => {
-        const pkg = JSON.parse(generateSdkPackageJson({ name: 'sdk', deps: { zod: false, luxon: false } }));
+        const pkg = JSON.parse(generateSdkPackageJson({ name: 'sdk', deps: { zod: false, luxon: false, decimal: false } }));
         expect(pkg.dependencies).toBeUndefined();
         expect(pkg.devDependencies['@types/luxon']).toBeUndefined();
     });
 
     it('adds zod as a runtime dependency when zod output is enabled', () => {
-        const pkg = JSON.parse(generateSdkPackageJson({ name: 'sdk', deps: { zod: true, luxon: false } }));
+        const pkg = JSON.parse(generateSdkPackageJson({ name: 'sdk', deps: { zod: true, luxon: false, decimal: false } }));
         expect(pkg.dependencies.zod).toBeDefined();
         expect(pkg.dependencies.luxon).toBeUndefined();
     });
 
     it('adds luxon (runtime) and @types/luxon (dev) when a date/time scalar is used', () => {
-        const pkg = JSON.parse(generateSdkPackageJson({ name: 'sdk', deps: { zod: false, luxon: true } }));
+        const pkg = JSON.parse(generateSdkPackageJson({ name: 'sdk', deps: { zod: false, luxon: true, decimal: false } }));
         expect(pkg.dependencies.luxon).toBeDefined();
         expect(pkg.devDependencies['@types/luxon']).toBeDefined();
     });
 
+    it('adds decimal.js, with no @types half, when a decimal scalar is used', () => {
+        const pkg = JSON.parse(generateSdkPackageJson({ name: 'sdk', deps: { zod: false, luxon: false, decimal: true } }));
+        expect(pkg.dependencies['decimal.js']).toBeDefined();
+        // decimal.js ships its own declarations, unlike luxon.
+        expect(pkg.devDependencies['@types/decimal.js']).toBeUndefined();
+        expect(pkg.dependencies.luxon).toBeUndefined();
+    });
+
     it('ends with a trailing newline', () => {
-        expect(generateSdkPackageJson({ name: 'sdk', deps: { zod: false, luxon: false } }).endsWith('}\n')).toBe(true);
+        expect(generateSdkPackageJson({ name: 'sdk', deps: { zod: false, luxon: false, decimal: false } }).endsWith('}\n')).toBe(true);
     });
 });
 

package/tests/codegen-server.test.ts

@@ -216,6 +216,54 @@ describe('createTypescriptPlugin (server)', () => {
         });
     });
 
+    describe('validateResponses', () => {
+        const userRoot = () =>
+            opRoot(
+                [opRoute('/users', [opOperation('get', { responses: [opResponse(200, 'User', 'application/json')] })])],
+                '/project/contracts/users.ck',
+            );
+
+        it('throws when validateResponses is set without zod', async () => {
+            const plugin = createTypescriptPlugin({ server: { validateResponses: true } }, '/project');
+            await expect(plugin.generateTargets!(inputs(), makeCtx('/project'))).rejects.toThrow(/validateResponses requires server\.zod/);
+        });
+
+        it('accepts validateResponses alongside zod', async () => {
+            const plugin = createTypescriptPlugin({ server: { zod: true, validateResponses: true } }, '/project');
+            await expect(plugin.generateTargets!(inputs(), makeCtx('/project'))).resolves.toBeUndefined();
+        });
+
+        it('threads validateResponses into the generated router', async () => {
+            const plugin = createTypescriptPlugin({ server: { zod: true, validateResponses: true } }, '/project');
+            const ctx = makeCtx('/project');
+            await plugin.generateTargets!(inputs([userRoot()]), ctx);
+            const router = [...ctx.emitted.entries()].find(([p]) => p.endsWith('.router.ts'))![1];
+            expect(router).toContain('ctx.body = await parseAndValidate(result, User, 500);');
+        });
+
+        it('leaves routers unvalidated without the flag', async () => {
+            const plugin = createTypescriptPlugin({ server: { zod: true } }, '/project');
+            const ctx = makeCtx('/project');
+            await plugin.generateTargets!(inputs([userRoot()]), ctx);
+            const router = [...ctx.emitted.entries()].find(([p]) => p.endsWith('.router.ts'))![1];
+            expect(router).toContain('ctx.body = result;');
+        });
+
+        // The set is derived from the contract roots, not handed in via `inputs`, so a
+        // `format(input=...)` model reaches the router codegen and suppresses its validation.
+        it('derives modelsWithTransform from the contract roots', async () => {
+            const plugin = createTypescriptPlugin({ server: { zod: true, validateResponses: true } }, '/project');
+            const ctx = makeCtx('/project');
+            const contracts = [
+                contractRoot([model('User', [field('id', scalarType('uuid'))], { inputCase: 'snake' })], '/project/contracts/users.ck'),
+            ];
+            await plugin.generateTargets!({ ...inputs([userRoot()]), contractRoots: contracts } as never, ctx);
+            const router = [...ctx.emitted.entries()].find(([p]) => p.endsWith('.router.ts'))![1];
+            expect(router).toContain('ctx.body = result;');
+            expect(router).not.toContain('parseAndValidate(result');
+        });
+    });
+
     describe('default plugin export', () => {
         it('plugin has name "typescript"', async () => {
             const { default: plugin } = await import('../src/index.js');

package/tests/helpers.ts

@@ -11,6 +11,7 @@ import type {
     LiteralTypeNode,
     UnionTypeNode,
     DiscriminatedUnionTypeNode,
+    IntersectionTypeNode,
     ModelRefTypeNode,
     InlineObjectTypeNode,
     LazyTypeNode,
@@ -64,6 +65,10 @@ export function discriminatedUnionType(discriminator: string, ...members: Contra
     return { kind: 'discriminatedUnion', discriminator, members };
 }
 
+export function intersectionType(...members: ContractTypeNode[]): IntersectionTypeNode {
+    return { kind: 'intersection', members };
+}
+
 export function refType(name: string): ModelRefTypeNode {
     return { kind: 'ref', name };
 }

package/tests/pipeline.test.ts

@@ -13,11 +13,11 @@ function compileContractSource(source: string) {
     return { root: contract, output, diag };
 }
 
-function compileOpSource(source: string, file = 'users.ck') {
+function compileOpSource(source: string, file = 'users.ck', options?: Parameters<typeof generateOp>[1]) {
     const diag = new DiagnosticCollector();
     const ck = parseCk(source, file, diag);
     const { op } = decomposeCk(ck);
-    const output = generateOp(op);
+    const output = generateOp(op, options);
     return { root: op, output, diag };
 }
 
@@ -33,6 +33,30 @@ describe('Contract pipeline (source -> parse -> codegen)', () => {
         expect(output).toContain(`active: z.preprocess((v) => v === 'true' ? true : v === 'false' ? false : v, z.boolean()).default(true)`);
     });
 
+    it('compiles a decimal contract end to end, keeping bounds as exact strings', () => {
+        // Exercises the real parse path rather than a hand-built AST: `buildScalarWithModifiers`
+        // has to keep `0.01` as a string instead of routing it through `Number()`.
+        const { output, root, diag } = compileContractSource(`
+contract Payslip: {
+    gross: decimal(min=0.01, max=999999.99, scale=2)
+    rate: decimal
+}
+`);
+        expect(diag.hasErrors()).toBe(false);
+
+        const gross = root.models[0]!.fields[0]!.type as { min: unknown; max: unknown; scale: unknown };
+        expect(gross.min).toBe('0.01');
+        expect(gross.max).toBe('999999.99');
+        expect(gross.scale).toBe(2);
+
+        expect(output).toContain("import { Decimal } from 'decimal.js';");
+        expect(output).toContain('Decimal.set({ toExpNeg: -9e15, toExpPos: 9e15 });');
+        expect(output).toContain(
+            `gross: _ZodDecimal.refine((v) => v.decimalPlaces() <= 2 && v.gte('0.01') && v.lte('999999.99'), { message: 'Must be at most 2 decimal places, at least 0.01, at most 999999.99' })`,
+        );
+        expect(output).toContain('rate: _ZodDecimal');
+    });
+
     it('compiles a contract with visibility to three-schema pattern', () => {
         const { output, diag } = compileContractSource(VISIBILITY_CONTRACT);
         expect(diag.hasErrors()).toBe(false);
@@ -103,6 +127,15 @@ describe('OP pipeline (source -> parse -> codegen)', () => {
         expect(output).toContain('ctx.status = 201');
     });
 
+    it('validates response bodies end to end when validateResponses is on', () => {
+        const { output, diag } = compileOpSource(SIMPLE_USERS_OP, 'users.ck', { validateResponses: true });
+        expect(diag.hasErrors()).toBe(false);
+        // GET returns array(User), POST returns User — both re-parsed against their own schema.
+        expect(output).toContain('ctx.body = await parseAndValidate(result, z.array(User), 500);');
+        expect(output).toContain('ctx.body = await parseAndValidate(result, User, 500);');
+        expect(output).toContain("import { parseAndValidate } from '@maroonedsoftware/zod';");
+    });
+
     it('compiles an operation with params, request, and response', () => {
         const { output, diag } = compileOpSource(PARAMETERIZED_OP);
         expect(diag.hasErrors()).toBe(false);