@contractkit/plugin-typescript 0.17.2 → 0.17.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contractkit/plugin-typescript",
-  "version": "0.17.2",
+  "version": "0.17.4",
   "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.13.0"
   },
   "devDependencies": {
-    "@repo/config-eslint": "0.3.1",
-    "@repo/config-typescript": "0.1.0"
+    "@repo/config-typescript": "0.1.0",
+    "@repo/config-eslint": "0.3.1"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --sourcemap --dts && tsc --emitDeclarationOnly --declaration",

package/src/codegen-contract.ts

@@ -40,6 +40,7 @@ export function modeToWrapper(mode: ObjectMode): string {
 
 // ─── Cross-file import resolution ─────────────────────────────────────────
 
+/** Cross-file context passed to `generateContract` to wire up imports and Input/Output variant tracking. */
 export interface ContractCodegenContext {
     /** Map from model name → absolute output file path */
     modelOutPaths: Map<string, string>;
@@ -250,7 +251,7 @@ function generateModel(
     const needsInputSplit = effective.fields.some(f => f.visibility !== 'normal') || (modelsWithInput?.has(effective.name) ?? false);
 
     const lines = needsInputSplit
-        ? generateThreeSchemaModel(effective, outPath, modelsWithInput, modelsWithWriteonly)
+        ? generateThreeSchemaModel(effective, outPath, modelsWithInput, modelsWithWriteonly, modelMap)
         : generateSimpleModel(effective, outPath);
 
     // Emit Output type alias when this model (transitively) has format(output=...)
@@ -342,7 +343,27 @@ function buildExtendChain(bases: string[], resolveName: (b: string) => string):
     return { head, tail };
 }
 
-function generateThreeSchemaModel(model: ModelNode, outPath?: string, modelsWithInput?: Set<string>, modelsWithWriteonly?: Set<string>): string[] {
+function collectEffectiveWritableFieldNames(modelName: string, modelMap: Map<string, ModelNode>): Set<string> {
+    const model = modelMap.get(modelName);
+    if (!model || model.type) return new Set();
+    const result = new Set<string>();
+    for (const base of model.bases ?? []) {
+        for (const f of collectEffectiveWritableFieldNames(base, modelMap)) result.add(f);
+    }
+    for (const field of model.fields) {
+        if (field.visibility === 'readonly') result.delete(field.name);
+        else result.add(field.name);
+    }
+    return result;
+}
+
+function generateThreeSchemaModel(
+    model: ModelNode,
+    outPath?: string,
+    modelsWithInput?: Set<string>,
+    modelsWithWriteonly?: Set<string>,
+    modelMap?: Map<string, ModelNode>,
+): string[] {
     const lines: string[] = [];
     const name = model.name;
 
@@ -388,9 +409,28 @@ function generateThreeSchemaModel(model: ModelNode, outPath?: string, modelsWith
     // extends ParentInput if parent has an Input variant, else extends parent read schema
     const writeFields = allFields.filter(f => f.visibility !== 'readonly');
     const writeBody = modelsWithInput ? renderInputFields(writeFields, modelsWithInput, model.mode) : renderFields(writeFields, model.mode);
+    // Fields that become readonly in this model but were writable in a base must be omitted from
+    // the base Input schema — Zod's .extend() cannot remove inherited fields.
+    const fieldsToOmit = new Set<string>();
+    if (bases.length > 0 && modelMap) {
+        for (const field of allFields) {
+            if (field.visibility === 'readonly') {
+                for (const base of bases) {
+                    if (collectEffectiveWritableFieldNames(base, modelMap).has(field.name)) {
+                        fieldsToOmit.add(field.name);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    const omitClause =
+        fieldsToOmit.size > 0
+            ? `.omit({ ${[...fieldsToOmit].map(f => `${quoteKey(f)}: true`).join(', ')} })`
+            : '';
     if (bases.length > 0) {
         const { head, tail } = buildExtendChain(bases, b => (modelsWithInput?.has(b) ? `${b}Input` : b));
-        lines.push(`export const ${name}Input = ${head}${tail}.extend({`);
+        lines.push(`export const ${name}Input = ${head}${tail}${omitClause}.extend({`);
     } else {
         lines.push(`export const ${name}Input = ${wrapper}({`);
     }
@@ -907,6 +947,7 @@ function rootNeedsDateTime(root: ContractRootNode): boolean {
     return root.models.some(m => (m.type && typeNeedsDateTime(m.type)) || m.fields.some(f => typeNeedsDateTime(f.type)));
 }
 
+/** Returns true if `type` (recursively) contains a scalar with the given `name`. */
 export function typeNeedsScalar(type: ContractTypeNode, name: string): boolean {
     switch (type.kind) {
         case 'scalar':
@@ -932,10 +973,12 @@ export function typeNeedsScalar(type: ContractTypeNode, name: string): boolean {
     }
 }
 
+/** Returns true if any model in `root` uses a scalar with the given `name`. */
 export function rootNeedsScalar(root: ContractRootNode, name: string): boolean {
     return root.models.some(m => (m.type && typeNeedsScalar(m.type, name)) || m.fields.some(f => typeNeedsScalar(f.type, name)));
 }
 
+/** Returns true if `type` (recursively) contains a `date`, `time`, or `datetime` scalar. */
 export function typeNeedsDateTime(type: ContractTypeNode): boolean {
     switch (type.kind) {
         case 'scalar':
@@ -955,6 +998,7 @@ export function typeNeedsDateTime(type: ContractTypeNode): boolean {
     }
 }
 
+/** Collect model names referenced in `root` that are not defined locally (need to be imported). */
 export function collectExternalRefs(root: ContractRootNode): string[] {
     const localNames = new Set(root.models.map(m => m.name));
     const refs = new Set<string>();

package/src/codegen-plain-types.ts

@@ -55,8 +55,10 @@ export function generatePlainTypes(root: ContractRootNode, context?: ContractCod
         lines.push('');
     }
 
+    const modelMap = new Map(root.models.map(m => [m.name, m]));
+
     for (const model of topoSortModels(root.models)) {
-        lines.push(...generateModel(model, context?.currentOutPath, allModelsWithInput, allModelsWithOutput));
+        lines.push(...generateModel(model, context?.currentOutPath, allModelsWithInput, allModelsWithOutput, modelMap));
         lines.push('');
     }
 
@@ -65,7 +67,13 @@ export function generatePlainTypes(root: ContractRootNode, context?: ContractCod
 
 // ─── Model ─────────────────────────────────────────────────────────────────
 
-function generateModel(model: ModelNode, outPath?: string, modelsWithInput?: Set<string>, modelsWithOutput?: Set<string>): string[] {
+function generateModel(
+    model: ModelNode,
+    outPath?: string,
+    modelsWithInput?: Set<string>,
+    modelsWithOutput?: Set<string>,
+    modelMap?: Map<string, ModelNode>,
+): string[] {
     // Type alias: Name : typeExpression
     if (model.type) {
         return generateTypeAlias(model, outPath, modelsWithInput, modelsWithOutput);
@@ -75,7 +83,7 @@ function generateModel(model: ModelNode, outPath?: string, modelsWithInput?: Set
     // transitively references models that have Input variants (captured in modelsWithInput).
     const needsInputSplit = model.fields.some(f => f.visibility !== 'normal') || (modelsWithInput?.has(model.name) ?? false);
 
-    const lines = needsInputSplit ? generateVisibilityModel(model, outPath, modelsWithInput) : generateSimpleModel(model, outPath);
+    const lines = needsInputSplit ? generateVisibilityModel(model, outPath, modelsWithInput, modelMap) : generateSimpleModel(model, outPath, modelMap);
 
     if (modelsWithOutput?.has(model.name)) {
         lines.push('');
@@ -84,6 +92,30 @@ function generateModel(model: ModelNode, outPath?: string, modelsWithInput?: Set
     return lines;
 }
 
+/** Recursively collect every field name defined on `bases` and their ancestors. Used to detect
+ * fields that the child re-declares without an explicit `override` keyword — those still need an
+ * `Omit<Base, …>` wrap, otherwise the child's narrower/incompatible declaration collides with the
+ * inherited one. */
+function collectInheritedFieldNames(bases: string[], modelMap: Map<string, ModelNode>): Set<string> {
+    const result = new Set<string>();
+    const visit = (name: string): void => {
+        const m = modelMap.get(name);
+        if (!m || m.type) return;
+        for (const f of m.fields) result.add(f.name);
+        for (const b of m.bases ?? []) visit(b);
+    };
+    for (const b of bases) visit(b);
+    return result;
+}
+
+/** Names of fields the child declaration overrides — explicit `override` plus any field whose
+ * name shadows an inherited one. The latter catches single-base redeclarations that omit the
+ * `override` keyword (e.g. narrowing `kind: BusinessRoleKind` → `kind: 'employee'`). */
+function computeOverrideNames(model: ModelNode, modelMap?: Map<string, ModelNode>): string[] {
+    const inherited = modelMap ? collectInheritedFieldNames(model.bases ?? [], modelMap) : new Set<string>();
+    return model.fields.filter(f => f.override || inherited.has(f.name)).map(f => f.name);
+}
+
 function generateComments(model: ModelNode, outPath?: string): string[] {
     const lines: string[] = [];
     lines.push('/**');
@@ -113,11 +145,11 @@ function generateTypeAlias(model: ModelNode, outPath?: string, modelsWithInput?:
     return lines;
 }
 
-/** Build the `extends` clause for a multi-base model.
- * Override-marked field names are wrapped in `Omit<Base, 'name1' | 'name2'>` per base so the
- * subclass can legally redeclare them with new types. TypeScript's `Omit<T, K extends keyof any>`
- * tolerates omit keys that don't appear on the base, so we omit unconditionally — no need to know
- * each base's actual field set. */
+/** Build the `extends` clause for a model.
+ * Each entry in `overrideNames` is wrapped in `Omit<Base, 'name1' | 'name2'>` per base so the
+ * subclass can legally redeclare those fields with new (possibly incompatible) types.
+ * TypeScript's `Omit<T, K extends keyof any>` tolerates omit keys that don't appear on the base,
+ * so we apply the same omit list to every base without per-base field-set lookup. */
 function buildExtendsClause(bases: string[], overrideNames: string[], baseNameResolver: (b: string) => string): string {
     if (bases.length === 0) return '';
     if (overrideNames.length === 0) return ` extends ${bases.map(baseNameResolver).join(', ')}`;
@@ -126,12 +158,12 @@ function buildExtendsClause(bases: string[], overrideNames: string[], baseNameRe
     return ` extends ${wrapped.join(', ')}`;
 }
 
-function generateSimpleModel(model: ModelNode, outPath?: string): string[] {
+function generateSimpleModel(model: ModelNode, outPath?: string, modelMap?: Map<string, ModelNode>): string[] {
     const lines: string[] = [];
     lines.push(...generateComments(model, outPath));
 
     const bases = model.bases ?? [];
-    const overrideNames = model.fields.filter(f => f.override).map(f => f.name);
+    const overrideNames = computeOverrideNames(model, modelMap);
     lines.push(`export interface ${model.name}${buildExtendsClause(bases, overrideNames, b => b)} {`);
 
     for (const field of model.fields) {
@@ -142,12 +174,12 @@ function generateSimpleModel(model: ModelNode, outPath?: string): string[] {
     return lines;
 }
 
-function generateVisibilityModel(model: ModelNode, outPath?: string, modelsWithInput?: Set<string>): string[] {
+function generateVisibilityModel(model: ModelNode, outPath?: string, modelsWithInput?: Set<string>, modelMap?: Map<string, ModelNode>): string[] {
     const lines: string[] = [];
     lines.push(...generateComments(model, outPath));
 
     const bases = model.bases ?? [];
-    const overrideNames = model.fields.filter(f => f.override).map(f => f.name);
+    const overrideNames = computeOverrideNames(model, modelMap);
 
     // Read type — omit writeonly fields
     const readFields = model.fields.filter(f => f.visibility !== 'writeonly');

package/tests/codegen-contract.test.ts

@@ -657,6 +657,32 @@ describe('generateContract', () => {
             // A has Input variant (because of readonly), B doesn't.
             expect(output).toContain('export const TestInput = AInput.extend(B.shape).extend({');
         });
+
+        it('omits override-readonly field from child Input schema', () => {
+            const root = contractRoot([
+                model('Base', [field('id', scalarType('uuid')), field('name', scalarType('string'))]),
+                model('Child', [field('name', scalarType('string'), { visibility: 'readonly', override: true })], {
+                    bases: ['Base'],
+                }),
+            ]);
+            const output = generateContract(root);
+            // Base has no visibility — no BaseInput
+            expect(output).not.toContain('BaseInput');
+            // Child re-declares 'name' as readonly, so 'name' must be omitted from Base before extending
+            expect(output).toContain('export const ChildInput = Base.omit({ name: true }).extend({');
+        });
+
+        it('omits override-readonly field inherited transitively through multiple bases', () => {
+            const root = contractRoot([
+                model('Root', [field('legalId', scalarType('uuid'))]),
+                model('Mid', [], { bases: ['Root'] }),
+                model('Child', [field('legalId', scalarType('uuid'), { visibility: 'readonly', override: true })], {
+                    bases: ['Mid'],
+                }),
+            ]);
+            const output = generateContract(root);
+            expect(output).toContain('export const ChildInput = Mid.omit({ legalId: true }).extend({');
+        });
     });
 
     // ─── Type alias Input variants ────────────────────────────────

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

@@ -419,6 +419,44 @@ describe('generatePlainTypes', () => {
             const output = generatePlainTypes(root);
             expect(output).toContain("export interface Test5 extends Omit<A, 'a' | 'b'> {");
         });
+
+        it('omits implicit single-base redeclarations even without explicit override', () => {
+            // BusinessRoleOfficer-style: child redeclares `kind` without `override` keyword,
+            // narrowing to an incompatible literal — must wrap base in Omit to compile.
+            const root = contractRoot([
+                model('Employee', [field('kind', literalType('employee')), field('title', scalarType('string'))]),
+                model('Officer', [field('kind', literalType('officer')), field('isControlPerson', scalarType('boolean'))], {
+                    bases: ['Employee'],
+                }),
+            ]);
+            const output = generatePlainTypes(root);
+            expect(output).toContain("export interface Officer extends Omit<Employee, 'kind'> {");
+        });
+
+        it('applies implicit-override Omit to both Read and Input interfaces', () => {
+            const root = contractRoot([
+                model('Employee', [
+                    field('id', scalarType('uuid'), { visibility: 'readonly' }),
+                    field('kind', literalType('employee')),
+                ]),
+                model('Officer', [field('kind', literalType('officer')), field('isControlPerson', scalarType('boolean'))], {
+                    bases: ['Employee'],
+                }),
+            ]);
+            const output = generatePlainTypes(root);
+            expect(output).toContain("export interface Officer extends Omit<Employee, 'kind'> {");
+            expect(output).toContain("export interface OfficerInput extends Omit<EmployeeInput, 'kind'> {");
+        });
+
+        it('detects redeclaration through transitive base chain', () => {
+            const root = contractRoot([
+                model('Root', [field('kind', scalarType('string'))]),
+                model('Mid', [], { bases: ['Root'] }),
+                model('Leaf', [field('kind', literalType('leaf'))], { bases: ['Mid'] }),
+            ]);
+            const output = generatePlainTypes(root);
+            expect(output).toContain("export interface Leaf extends Omit<Mid, 'kind'> {");
+        });
     });
 
     // ─── Type alias Input variants ────────────────────────────────