@contractkit/plugin-typescript 0.23.0 → 0.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contractkit/plugin-typescript",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "description": "ContractKit built-in plugin: TypeScript codegen (SDK clients, Koa routers, Zod schemas, plain types)",
   "author": {
     "name": "Marooned Software",
@@ -29,8 +29,8 @@
     "@contractkit/core": "0.17.0"
   },
   "devDependencies": {
-    "@repo/config-typescript": "0.1.0",
-    "@repo/config-eslint": "0.3.1"
+    "@repo/config-eslint": "0.3.1",
+    "@repo/config-typescript": "0.1.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --sourcemap --dts && tsc --emitDeclarationOnly --declaration",

package/src/codegen-contract.ts

@@ -300,7 +300,17 @@ function generateSimpleModel(model: ModelNode, outPath?: string): string[] {
         for (const field of model.fields) {
             const inputKey = applyCase(field.name, inputCase);
             const outputKey = applyCase(field.name, outputCase);
-            lines.push(`    ${quoteKey(outputKey)}: data.${inputKey},`);
+            if (field.optional) {
+                // Conditional spread keeps the field optional (`k?: T`) in the inferred
+                // z.output / z.input type, instead of widening to required-nullable (`k: T | undefined`).
+                // Consumer code built with `...(x ? { k: x } : {})` is only assignable to the optional form.
+                // When inputCase is set, the input schema uses `.nullish()` so the guard must reject both
+                // null and undefined; otherwise `.optional()` only allows undefined.
+                const guard = hasInputTransform ? `data.${inputKey} != null` : `data.${inputKey} !== undefined`;
+                lines.push(`    ...(${guard} ? { ${quoteKey(outputKey)}: data.${inputKey} } : {}),`);
+            } else {
+                lines.push(`    ${quoteKey(outputKey)}: data.${inputKey},`);
+            }
         }
         lines.push(`}));`);
         // When only outputCase is set, the developer-facing type is the schema's
@@ -738,9 +748,13 @@ function renderInlineObject(o: InlineObjectTypeNode, parseCaseTransform?: 'snake
         const transformEntries = o.fields
             .map(f => {
                 const snakeKey = camelToSnake(f.name);
-                // Optional fields use .nullish() on input; coerce null → undefined in output
-                const val = f.optional ? `data.${snakeKey} ?? undefined` : `data.${snakeKey}`;
-                return `    ${quoteKey(f.name)}: ${val},`;
+                // Optional fields use .nullish() on input. Conditional spread (instead of `?? undefined`)
+                // keeps the key optional in the inferred output type (`k?: T`) rather than widening to
+                // required-nullable (`k: T | undefined`).
+                if (f.optional) {
+                    return `    ...(data.${snakeKey} != null ? { ${quoteKey(f.name)}: data.${snakeKey} } : {}),`;
+                }
+                return `    ${quoteKey(f.name)}: data.${snakeKey},`;
             })
             .join('\n');
         return `${wrapper}({\n${joined}\n}).transform(data => ({\n${transformEntries}\n}))`;
@@ -751,8 +765,10 @@ function renderInlineObject(o: InlineObjectTypeNode, parseCaseTransform?: 'snake
         const transformEntries = o.fields
             .map(f => {
                 const pascalKey = camelToPascal(f.name);
-                const val = f.optional ? `data.${pascalKey} ?? undefined` : `data.${pascalKey}`;
-                return `    ${quoteKey(f.name)}: ${val},`;
+                if (f.optional) {
+                    return `    ...(data.${pascalKey} != null ? { ${quoteKey(f.name)}: data.${pascalKey} } : {}),`;
+                }
+                return `    ${quoteKey(f.name)}: data.${pascalKey},`;
             })
             .join('\n');
         return `${wrapper}({\n${joined}\n}).transform(data => ({\n${transformEntries}\n}))`;

package/tests/codegen-contract.test.ts

@@ -1060,9 +1060,59 @@ describe('generateContract', () => {
                 /export const Child = z\.strictObject\(\{[\s\S]*grant_type:[\s\S]*client_id:[\s\S]*client_secret:[\s\S]*\}\)\.transform/,
             );
             expect(output).toContain('grantType: data.grant_type');
-            expect(output).toContain('clientId: data.client_id');
+            expect(output).toContain('clientId: data.client_id,');
             expect(output).toContain('clientSecret: data.client_secret');
             expect(output).toContain('export type Child = z.output<typeof Child>');
         });
+
+        it('input=snake: optional fields use conditional spread guarded by `!= null`', () => {
+            // .nullish() on input accepts null and undefined; conditional spread keeps the field
+            // optional in the inferred output type (`k?: T`) instead of widening to required-nullable
+            // (`k: T | undefined`). The `!= null` guard omits the key for both null and undefined.
+            const root = contractRoot([
+                model(
+                    'User',
+                    [field('firstName', scalarType('string')), field('clientId', scalarType('uuid'), { optional: true })],
+                    { inputCase: 'snake' },
+                ),
+            ]);
+            const output = generateContract(root);
+            expect(output).toContain('client_id: z.uuid().nullish()');
+            expect(output).toContain('firstName: data.first_name,');
+            expect(output).toContain('...(data.client_id != null ? { clientId: data.client_id } : {}),');
+            expect(output).not.toContain('?? undefined');
+        });
+
+        it('output=snake: optional fields use conditional spread guarded by `!== undefined`', () => {
+            // With only outputCase set, input is `.optional()` (undefined-only). Conditional spread keeps
+            // the field optional in the inferred z.input type so consumers building values with
+            // `...(x ? { k: x } : {})` are assignable.
+            const root = contractRoot([
+                model('Token', [field('accessToken', scalarType('string')), field('refreshToken', scalarType('string'), { optional: true })], {
+                    outputCase: 'snake',
+                }),
+            ]);
+            const output = generateContract(root);
+            expect(output).toContain('refreshToken: z.string().optional()');
+            expect(output).toContain('access_token: data.accessToken,');
+            expect(output).toContain('...(data.refreshToken !== undefined ? { refresh_token: data.refreshToken } : {}),');
+            expect(output).not.toContain('?? undefined');
+        });
+
+        it('input=pascal: inline-object optional fields use conditional spread guarded by `!= null`', () => {
+            const dataType = inlineObjectType([
+                field('id', scalarType('uuid')),
+                field('amount', scalarType('number'), { optional: true }),
+            ]);
+            const root = contractRoot([
+                model('Webhook', [field('event', scalarType('string')), field('data', dataType)], { inputCase: 'pascal' }),
+            ]);
+            const output = generateContract(root);
+            // Inline object emits its own transform inside the Webhook input shape.
+            expect(output).toContain('Amount: z.coerce.number().nullish()');
+            expect(output).toContain('id: data.Id,');
+            expect(output).toContain('...(data.Amount != null ? { amount: data.Amount } : {}),');
+            expect(output).not.toContain('?? undefined');
+        });
     });
 });