@contractkit/plugin-typescript 0.28.2 → 0.29.0

package/tests/codegen-operation.test.ts

@@ -658,6 +658,77 @@ describe('generateOperation', () => {
             const output = generateOp(root, { modelsWithOutput: new Set(['AuthToken']) });
             expect(output).toContain('result: AuthTokenOutput[]');
         });
+
+        // Scalar response bodies used to emit the .ck scalar name verbatim (`result: binary`),
+        // which only happened to compile for `string`.
+        describe('scalar response bodies map to the server-side TypeScript type', () => {
+            const cases: Array<[string, string]> = [
+                ['binary', 'Buffer'],
+                ['int', 'number'],
+                ['number', 'number'],
+                ['bigint', 'bigint'],
+                ['boolean', 'boolean'],
+                ['string', 'string'],
+                ['uuid', 'string'],
+                ['email', 'string'],
+                ['url', 'string'],
+                ['datetime', 'DateTime'],
+                ['date', 'DateTime'],
+                ['time', 'DateTime'],
+                ['duration', 'Duration'],
+                ['interval', 'string'],
+                ['json', '_JsonValue'],
+                ['object', 'Record<string, unknown>'],
+                ['unknown', 'unknown'],
+                ['null', 'null'],
+            ];
+
+            for (const [scalar, tsType] of cases) {
+                it(`renders ${scalar} as ${tsType}`, () => {
+                    const root = opRoot([
+                        opRoute('/x', [
+                            opOperation('get', {
+                                responses: [opResponse(200, scalarType(scalar as never), 'application/octet-stream')],
+                            }),
+                        ]),
+                    ]);
+                    expect(generateOp(root)).toContain(`const result: ${tsType} = await service.list();`);
+                });
+            }
+
+            it('renders an array of binary as Buffer[]', () => {
+                const root = opRoot([
+                    opRoute('/x', [opOperation('get', { responses: [opResponse(200, arrayType(scalarType('binary')), 'application/json')] })]),
+                ]);
+                expect(generateOp(root)).toContain('const result: Buffer[] = await service.list();');
+            });
+        });
+
+        describe('luxon imports cover every scalar that references a luxon class', () => {
+            it('imports Duration for a duration response body', () => {
+                const root = opRoot([opRoute('/x', [opOperation('get', { responses: [opResponse(200, scalarType('duration'), 'application/json')] })])]);
+                expect(generateOp(root)).toContain("import { Duration } from 'luxon';");
+            });
+
+            it('imports Interval and emits the _ZodInterval helper for an interval body', () => {
+                const root = opRoot([opRoute('/x', [opOperation('get', { responses: [opResponse(200, scalarType('interval'), 'application/json')] })])]);
+                const output = generateOp(root);
+                expect(output).toContain("import { Interval } from 'luxon';");
+                expect(output).toContain('const _ZodInterval =');
+            });
+
+            it('imports DateTime and Duration together when both are used', () => {
+                const root = opRoot([
+                    opRoute('/x', [
+                        opOperation('post', {
+                            request: opRequest(scalarType('datetime')),
+                            responses: [opResponse(200, scalarType('duration'), 'application/json')],
+                        }),
+                    ]),
+                ]);
+                expect(generateOp(root)).toContain("import { DateTime, Duration } from 'luxon';");
+            });
+        });
     });
 
     // ─── Service inference ────────────────────────────────────────

package/tests/codegen-plain-types.test.ts

@@ -98,6 +98,54 @@ describe('generatePlainTypes', () => {
             expect(output).toContain('o: Record<string, unknown>;');
             expect(output).toContain('bin: Blob;');
         });
+
+        // `binary` is the one scalar with no runtime-independent TypeScript type: a fetch client
+        // sees a Blob, a Koa handler sees the Buffer that _ZodBinary validates.
+        describe('binary follows the render target', () => {
+            const ctx = (target: 'client' | 'server') => ({
+                modelOutPaths: new Map<string, string>(),
+                currentOutPath: 'out.ts',
+                target,
+            });
+
+            it('renders Buffer for the server target', () => {
+                const root = contractRoot([model('M', [field('bin', scalarType('binary'))])]);
+                expect(generatePlainTypes(root, ctx('server'))).toContain('bin: Buffer;');
+            });
+
+            it('renders Blob for the client target', () => {
+                const root = contractRoot([model('M', [field('bin', scalarType('binary'))])]);
+                expect(generatePlainTypes(root, ctx('client'))).toContain('bin: Blob;');
+            });
+
+            it('defaults to the client target when unset', () => {
+                const root = contractRoot([model('M', [field('bin', scalarType('binary'))])]);
+                expect(generatePlainTypes(root)).toContain('bin: Blob;');
+            });
+
+            it('applies to nested and compound positions', () => {
+                const root = contractRoot([
+                    model('M', [
+                        field('list', arrayType(scalarType('binary'))),
+                        field('nested', inlineObjectType([field('bin', scalarType('binary'))])),
+                        field('map', recordType(scalarType('string'), scalarType('binary'))),
+                    ]),
+                ]);
+                const output = generatePlainTypes(root, ctx('server'));
+                expect(output).toContain('list: Buffer[];');
+                expect(output).toContain('nested: { bin: Buffer };');
+                expect(output).toContain('map: Record<string, Buffer>;');
+            });
+
+            it('applies to type aliases and their Input variants', () => {
+                const root = contractRoot([
+                    model('Blob1', [field('bin', scalarType('binary')), field('secret', scalarType('binary'), { visibility: 'readonly' })]),
+                ]);
+                const output = generatePlainTypes(root, { ...ctx('server'), modelsWithInput: new Set(['Blob1']) });
+                expect(output).toContain('bin: Buffer;');
+                expect(output).not.toContain('Blob;');
+            });
+        });
     });
 
     // ─── Compound types ───────────────────────────────────────────

package/tests/codegen-server.test.ts

@@ -120,6 +120,43 @@ describe('createTypescriptPlugin (server)', () => {
             expect(typeContent).not.toContain('z.');
             expect(typeContent).toContain('export interface User');
         });
+
+        it('renders binary as Buffer in server plain types', async () => {
+            const plugin = createTypescriptPlugin({ server: { output: { types: 'src/types/{filename}.ts' } } }, '/project');
+            const ctx = makeCtx('/project');
+            const contractRoots = [contractRoot([model('Upload', [field('data', scalarType('binary'))])], '/project/contracts/uploads.ck')];
+            await plugin.generateTargets!(inputs([], contractRoots as any), ctx);
+            const typeContent = [...ctx.emitted.values()][0]!;
+            expect(typeContent).toContain('data: Buffer;');
+            expect(typeContent).not.toContain('Blob');
+        });
+
+        it('renders binary as Blob in SDK plain types', async () => {
+            const plugin = createTypescriptPlugin({ sdk: { output: { types: 'src/types/{filename}.ts' } } }, '/project');
+            const ctx = makeCtx('/project');
+            const contractRoots = [contractRoot([model('Upload', [field('data', scalarType('binary'))])], '/project/contracts/uploads.ck')];
+            await plugin.generateTargets!(inputs([], contractRoots as any), ctx);
+            const typeContent = [...ctx.emitted.values()].find(c => c.includes('interface Upload'))!;
+            expect(typeContent).toContain('data: Blob;');
+        });
+
+        it('honors types.target on the standalone types sub-generator', async () => {
+            const contractRoots = [contractRoot([model('Upload', [field('data', scalarType('binary'))])], '/project/contracts/uploads.ck')];
+
+            const serverCtx = makeCtx('/project');
+            await createTypescriptPlugin({ types: { output: 'src/{filename}.types.ts', target: 'server' } }, '/project').generateTargets!(
+                inputs([], contractRoots as any),
+                serverCtx,
+            );
+            expect([...serverCtx.emitted.values()][0]!).toContain('data: Buffer;');
+
+            const defaultCtx = makeCtx('/project');
+            await createTypescriptPlugin({ types: { output: 'src/{filename}.types.ts' } }, '/project').generateTargets!(
+                inputs([], contractRoots as any),
+                defaultCtx,
+            );
+            expect([...defaultCtx.emitted.values()][0]!).toContain('data: Blob;');
+        });
     });
 
     describe('generated content', () => {