@contractkit/plugin-typescript 0.16.1 → 0.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contractkit/plugin-typescript",
-  "version": "0.16.1",
+  "version": "0.17.0",
   "description": "ContractKit built-in plugin: TypeScript codegen (SDK clients, Koa routers, Zod schemas, plain types)",
   "author": {
     "name": "Marooned Software",

package/src/codegen-contract.ts

@@ -22,6 +22,11 @@ import {
     collectExternalOutputRefs as ckCollectExternalOutputRefs,
 } from '@contractkit/core';
 
+/**
+ * Maps a ContractKit object mode to its Zod constructor name.
+ *
+ * @returns `"z.strictObject"` | `"z.object"` | `"z.looseObject"`
+ */
 export function modeToWrapper(mode: ObjectMode): string {
     switch (mode) {
         case 'strict':
@@ -111,6 +116,16 @@ function generateComments(model: ModelNode, outPath?: string): string[] {
     return lines;
 }
 
+/**
+ * Generate a TypeScript module containing Zod schemas for every model in `root`.
+ *
+ * Emits up to three schemas per model when visibility modifiers are present:
+ * `ModelBase` (all fields), `Model` (read — no writeonly), `ModelInput` (write — no readonly).
+ *
+ * @param root - The parsed contract root node.
+ * @param context - Optional cross-file context for import resolution and Input/Output variant tracking.
+ * @returns The full TypeScript source as a string.
+ */
 export function generateContract(root: ContractRootNode, context?: ContractCodegenContext): string {
     const needsDateTime = rootNeedsDateTime(root);
     const needsDuration = rootNeedsScalar(root, 'duration');
@@ -464,6 +479,14 @@ function renderField(field: FieldNode, defaultMode?: ObjectMode): string[] {
 
 // ─── Type rendering ────────────────────────────────────────────────────────
 
+/**
+ * Render a ContractKit AST type node as a Zod schema expression string.
+ *
+ * @param parseCaseTransform - When set, generates a `.transform()` that remaps incoming keys from
+ *   the given casing (`'snake'` | `'pascal'`) to camelCase for `inlineObject` types.
+ * @param defaultMode - Fallback object mode (`'strict'` | `'strip'` | `'loose'`) when the node
+ *   doesn't specify its own mode.
+ */
 export function renderType(type: ContractTypeNode, parseCaseTransform?: 'snake' | 'pascal', defaultMode?: ObjectMode): string {
     switch (type.kind) {
         case 'scalar':
@@ -631,25 +654,34 @@ function renderDiscriminatedUnion(u: DiscriminatedUnionTypeNode, parseCaseTransf
 
 function renderIntersection(i: IntersectionTypeNode, parseCaseTransform?: 'snake' | 'pascal', defaultMode?: ObjectMode): string {
     const [first, ...rest] = i.members;
-    // When the pattern is ref & { inlineObject(s) }, use .extend() to produce a
-    // single merged ZodObject. Using .and(z.strictObject) breaks because each
-    // strict side rejects the other side's keys during intersection parsing.
-    if (first && first.kind === 'ref' && rest.length > 0 && rest.every(m => m.kind === 'inlineObject')) {
-        const allFields = rest.flatMap(m => (m as InlineObjectTypeNode).fields);
-        const fieldLines =
-            parseCaseTransform === 'snake'
-                ? renderFieldsAsSnakeCase(allFields, defaultMode)
-                      .map(l => `    ${l}`)
-                      .join('\n')
-                : parseCaseTransform === 'pascal'
-                  ? renderFieldsAsPascalCase(allFields, defaultMode)
-                        .map(l => `    ${l}`)
-                        .join('\n')
-                  : allFields
-                        .flatMap(f => renderField(f, defaultMode))
-                        .map(l => `    ${l}`)
-                        .join('\n');
-        return `${first.name}.extend({\n${fieldLines}\n})`;
+    // When the pattern is ref & (ref | inlineObject)*, use .extend() chains to
+    // produce a single ZodObject. .and() breaks strict objects — each strict side
+    // rejects the other side's keys during intersection parsing, and ZodIntersection
+    // has no .strict() method.
+    if (first && first.kind === 'ref' && rest.length > 0 && rest.every(m => m.kind === 'ref' || m.kind === 'inlineObject')) {
+        let expr = first.name;
+        for (const member of rest) {
+            if (member.kind === 'ref') {
+                expr += `.extend(${member.name}.shape)`;
+            } else {
+                const m = member as InlineObjectTypeNode;
+                const fieldLines =
+                    parseCaseTransform === 'snake'
+                        ? renderFieldsAsSnakeCase(m.fields, defaultMode)
+                              .map(l => `    ${l}`)
+                              .join('\n')
+                        : parseCaseTransform === 'pascal'
+                          ? renderFieldsAsPascalCase(m.fields, defaultMode)
+                                .map(l => `    ${l}`)
+                                .join('\n')
+                          : m.fields
+                                .flatMap(f => renderField(f, defaultMode))
+                                .map(l => `    ${l}`)
+                                .join('\n');
+                expr += `.extend({\n${fieldLines}\n})`;
+            }
+        }
+        return expr;
     }
     let expr = renderType(first!, parseCaseTransform, defaultMode);
     for (const member of rest) {
@@ -730,11 +762,20 @@ export function renderInputType(type: ContractTypeNode, modelsWithInput?: Set<st
             return `z.discriminatedUnion("${escapeString(type.discriminator)}", [${type.members.map(m => renderInputType(m, modelsWithInput, defaultMode)).join(', ')}])`;
         case 'intersection': {
             const [first, ...rest] = type.members;
-            if (first && first.kind === 'ref' && rest.length > 0 && rest.every(m => m.kind === 'inlineObject')) {
-                const base = modelsWithInput?.has(first.name) ? `${first.name}Input` : first.name;
-                const allFields = rest.flatMap(m => (m as InlineObjectTypeNode).fields);
-                const fieldLines = allFields.map(f => `    ${renderInputField(f, modelsWithInput ?? new Set(), defaultMode)}`).join('\n');
-                return `${base}.extend({\n${fieldLines}\n})`;
+            if (first && first.kind === 'ref' && rest.length > 0 && rest.every(m => m.kind === 'ref' || m.kind === 'inlineObject')) {
+                let expr = modelsWithInput?.has(first.name) ? `${first.name}Input` : first.name;
+                for (const member of rest) {
+                    if (member.kind === 'ref') {
+                        const name = modelsWithInput?.has(member.name) ? `${member.name}Input` : member.name;
+                        expr += `.extend(${name}.shape)`;
+                    } else {
+                        const fieldLines = (member as InlineObjectTypeNode).fields
+                            .map(f => `    ${renderInputField(f, modelsWithInput ?? new Set(), defaultMode)}`)
+                            .join('\n');
+                        expr += `.extend({\n${fieldLines}\n})`;
+                    }
+                }
+                return expr;
             }
             let expr = renderInputType(first!, modelsWithInput, defaultMode);
             for (const member of rest) {
@@ -798,11 +839,20 @@ export function renderQueryType(type: ContractTypeNode, modelsWithInput?: Set<st
         }
         case 'intersection': {
             const [first, ...rest] = type.members;
-            if (first && first.kind === 'ref' && rest.length > 0 && rest.every(m => m.kind === 'inlineObject')) {
-                const base = modelsWithInput?.has(first.name) ? `${first.name}Input` : first.name;
-                const allFields = rest.flatMap(m => (m as InlineObjectTypeNode).fields);
-                const fieldLines = allFields.map(f => `    ${renderQueryField(f, modelsWithInput, defaultMode)}`).join('\n');
-                return `${base}.extend({\n${fieldLines}\n})`;
+            if (first && first.kind === 'ref' && rest.length > 0 && rest.every(m => m.kind === 'ref' || m.kind === 'inlineObject')) {
+                let expr = modelsWithInput?.has(first.name) ? `${first.name}Input` : first.name;
+                for (const member of rest) {
+                    if (member.kind === 'ref') {
+                        const name = modelsWithInput?.has(member.name) ? `${member.name}Input` : member.name;
+                        expr += `.extend(${name}.shape)`;
+                    } else {
+                        const fieldLines = (member as InlineObjectTypeNode).fields
+                            .map(f => `    ${renderQueryField(f, modelsWithInput, defaultMode)}`)
+                            .join('\n');
+                        expr += `.extend({\n${fieldLines}\n})`;
+                    }
+                }
+                return expr;
             }
             let expr = renderQueryType(first!, modelsWithInput, defaultMode);
             for (const member of rest) {

package/tests/codegen-contract.test.ts

@@ -713,6 +713,44 @@ describe('generateContract', () => {
             expect(output).toContain('export const UserId = z.uuid()');
             expect(output).not.toContain('UserIdInput');
         });
+
+        it('ref & ref type alias uses .extend(B.shape) instead of .and()', () => {
+            const root = contractRoot([
+                model('Pagination', [field('page', scalarType('int'))]),
+                model('Filter', [field('status', scalarType('string'), { optional: true })]),
+                model('ListQuery', [], {
+                    type: {
+                        kind: 'intersection',
+                        members: [
+                            { kind: 'ref', name: 'Pagination' },
+                            { kind: 'ref', name: 'Filter' },
+                        ],
+                    },
+                }),
+            ]);
+            const output = generateContract(root);
+            expect(output).toContain('export const ListQuery = Pagination.extend(Filter.shape)');
+            expect(output).not.toContain('.and(');
+        });
+
+        it('ref & ref type alias substitutes Input variant when base has Input', () => {
+            const root = contractRoot([
+                model('Pagination', [field('page', scalarType('int')), field('total', scalarType('int'), { visibility: 'readonly' })]),
+                model('Filter', [field('status', scalarType('string'), { optional: true })]),
+                model('ListQuery', [], {
+                    type: {
+                        kind: 'intersection',
+                        members: [
+                            { kind: 'ref', name: 'Pagination' },
+                            { kind: 'ref', name: 'Filter' },
+                        ],
+                    },
+                }),
+            ]);
+            const output = generateContract(root);
+            expect(output).toContain('export const ListQuery = Pagination.extend(Filter.shape)');
+            expect(output).toContain('export const ListQueryInput = PaginationInput.extend(Filter.shape)');
+        });
     });
 
     // ─── Description ──────────────────────────────────────────────

package/tests/codegen-operation.test.ts

@@ -324,6 +324,45 @@ describe('generateOperation', () => {
             expect(output).toMatch(/import \{[^}]*\bPaginationInput\b[^}]*\} from /);
         });
 
+        it('ref & ref intersection query uses .extend(B.shape) not .and()', () => {
+            const root = opRoot([
+                opRoute('/persons', [
+                    opOperation('get', {
+                        query: {
+                            kind: 'intersection',
+                            members: [
+                                { kind: 'ref', name: 'Pagination' },
+                                { kind: 'ref', name: 'PersonQuery' },
+                            ],
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        } as any,
+                    }),
+                ]),
+            ]);
+            const output = generateOp(root);
+            expect(output).toContain('Pagination.extend(PersonQuery.shape)');
+            expect(output).not.toContain('.and(');
+        });
+
+        it('ref & ref intersection query substitutes Input variants', () => {
+            const root = opRoot([
+                opRoute('/persons', [
+                    opOperation('get', {
+                        query: {
+                            kind: 'intersection',
+                            members: [
+                                { kind: 'ref', name: 'Pagination' },
+                                { kind: 'ref', name: 'PersonQuery' },
+                            ],
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        } as any,
+                    }),
+                ]),
+            ]);
+            const output = generateOp(root, { modelsWithInput: new Set(['Pagination']) });
+            expect(output).toContain('PaginationInput.extend(PersonQuery.shape)');
+        });
+
         it('wraps ContractTypeNode intersection query with array fields using z.preprocess', () => {
             const root = opRoot([
                 opRoute('/offers', [

package/.turbo/turbo-build.log

@@ -1,15 +0,0 @@
-
-> @contractkit/plugin-typescript@0.16.0 build /Users/robert/projects/contractkit/packages/plugin-typescript
-> tsup src/index.ts --format esm --sourcemap --dts && tsc --emitDeclarationOnly --declaration
-
-CLI Building entry: src/index.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.5.1
-CLI Target: esnext
-ESM Build start
-ESM dist/index.js     123.76 KB
-ESM dist/index.js.map 267.25 KB
-ESM ⚡️ Build success in 95ms
-DTS Build start
-DTS ⚡️ Build success in 744ms
-DTS dist/index.d.ts 3.44 KB

package/.turbo/turbo-test.log

@@ -1,19 +0,0 @@
-
-> @contractkit/plugin-typescript@0.16.0 test /Users/robert/projects/contractkit/packages/plugin-typescript
-> vitest run
-
-
- RUN  v4.1.5 /Users/robert/projects/contractkit/packages/plugin-typescript
-
- ✓ tests/codegen-contract.test.ts (120 tests) 10ms
- ✓ tests/codegen-plain-types.test.ts (58 tests) 10ms
- ✓ tests/codegen-sdk.test.ts (123 tests) 16ms
- ✓ tests/codegen-operation.test.ts (86 tests) 9ms
- ✓ tests/pipeline.test.ts (25 tests) 29ms
- ✓ tests/codegen-server.test.ts (15 tests) 6ms
-
- Test Files  6 passed (6)
-      Tests  427 passed (427)
-   Start at  08:51:34
-   Duration  472ms (transform 591ms, setup 0ms, import 1.33s, tests 80ms, environment 0ms)
-