openapi-contract-kit 0.0.3 → 0.0.5

package/CHANGELOG.md

@@ -1,6 +1,13 @@
 # Changelog
 
-All notable changes to this project will be documented in this file.
+
+## [0.0.5] - 2026-09-12
+
+- Tighten generated pragmatic email-format validation and modularize primitive and constraint renderers.
+
+## [0.0.4] - 2026-09-12
+
+- Lowered the supported Node.js baseline to Node 24 and added CI coverage for Node 24 and 26.
 
 ## [0.0.3] - 2026-09-12
 

package/README.md

@@ -19,7 +19,7 @@ JSON-first OpenAPI 3.1 contract generation and runtime validation for TypeScript
 pnpm add -D openapi-contract-kit
 ```
 
-Requires Node.js 26 and pnpm 12.3.4.
+Requires Node.js 24 or newer and pnpm 12.3.4.
 
 ## Quick start
 
@@ -63,7 +63,7 @@ if (!result.ok) {
 
 Validation errors contain a path, keyword, and message. Successful validation returns the original input without mutating or cloning it.
 
-The focused fixture and acceptance tests cover structural validation: object shape, declared fields, primitive types, arrays, nullability, references, unions, and additional-property behavior. They do not require form-level checks such as email format, string length, patterns, or numeric ranges. Those constraints remain available when declared in consumer schemas.
+The focused fixture and acceptance tests cover structural validation, primitive types, references, unions, additional-property behavior, and declared email format validation. String length, patterns, and numeric ranges remain available when declared in consumer schemas.
 
 ## Supported input
 

package/dist/src/generator/emitMakers.js

@@ -1,29 +1,10 @@
-function indent(lines, spaces = 2) {
-    const prefix = ' '.repeat(spaces);
-    return lines.map((line) => (line.length === 0 ? line : `${prefix}${line}`));
-}
-function typeExpression(type, value = 'value') {
-    switch (type) {
-        case 'array':
-            return `Array.isArray(${value})`;
-        case 'boolean':
-            return `typeof ${value} === 'boolean'`;
-        case 'integer':
-            return `typeof ${value} === 'number' && Number.isFinite(${value}) && Number.isInteger(${value})`;
-        case 'null':
-            return `${value} === null`;
-        case 'number':
-            return `typeof ${value} === 'number' && Number.isFinite(${value})`;
-        case 'object':
-            return `typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value})`;
-        case 'string':
-            return `typeof ${value} === 'string'`;
-        default: {
-            const exhaustive = type;
-            throw new Error(`Unsupported normalised schema type "${exhaustive}"`);
-        }
-    }
-}
+import { renderArrayConstraints } from './validations/render-arrays.js';
+import { renderNumberConstraints } from './validations/render-numbers.js';
+import { renderObjectConstraints } from './validations/render-objects.js';
+import { renderPrimitiveConstraints, typeExpression, } from './validations/render-primitives.js';
+import { renderStringConstraints } from './validations/render-strings.js';
+import { renderAllOf, renderUnionConstraint, } from './validations/render-unions.js';
+import { indent } from './validations/render-utils.js';
 class MakerRenderer {
     #counter = 0;
     #functions = [];
@@ -155,168 +136,17 @@ export function make${name}(input: unknown): Result<${name}> {
                 'return false;',
             ]), '}');
         }
-        if (schema.constValue !== undefined) {
-            lines.push(`if (!Object.is(value, ${JSON.stringify(schema.constValue)})) {`, ...indent([
-                `errors.push({ path, keyword: 'const', message: 'Expected the documented constant value' });`,
-            ]), '}');
-        }
-        if (schema.enumValues !== null) {
-            const values = schema.enumValues
-                .map((value) => JSON.stringify(value))
-                .join(', ');
-            lines.push(`if (![${values}].some((candidate) => Object.is(candidate, value))) {`, ...indent([
-                `errors.push({ path, keyword: 'enum', message: 'Expected a documented enum value' });`,
-            ]), '}');
-        }
-        for (const child of children.allOf) {
-            lines.push(`${child}(value, path, errors);`);
-        }
-        this.#renderUnionConstraint(lines, 'anyOf', children.anyOf, false);
-        this.#renderUnionConstraint(lines, 'oneOf', children.oneOf, true);
-        this.#renderStringConstraints(lines, schema);
-        this.#renderNumberConstraints(lines, schema);
-        this.#renderArrayConstraints(lines, children.items);
-        this.#renderObjectConstraints(lines, schema, children);
+        renderPrimitiveConstraints(lines, schema.constValue, schema.enumValues);
+        renderAllOf(lines, children.allOf);
+        renderUnionConstraint(lines, 'anyOf', children.anyOf, false);
+        renderUnionConstraint(lines, 'oneOf', children.oneOf, true);
+        renderStringConstraints(lines, schema);
+        renderNumberConstraints(lines, schema);
+        renderArrayConstraints(lines, children.items);
+        renderObjectConstraints(lines, schema, children);
         lines.push('return errors.length === errorCount;');
         return lines;
     }
-    #renderUnionConstraint(lines, keyword, branches, isExclusive) {
-        if (branches.length === 0) {
-            return;
-        }
-        const variable = `${keyword}Matches`;
-        lines.push(`let ${variable} = 0;`);
-        for (const [index, branch] of branches.entries()) {
-            const errorsName = `${keyword}Errors${index}`;
-            lines.push(`const ${errorsName}: ValidationIssue[] = [];`, `if (${branch}(value, path, ${errorsName})) {`, ...indent([`${variable} += 1;`]), '}');
-        }
-        const invalidExpression = isExclusive
-            ? `${variable} !== 1`
-            : `${variable} === 0`;
-        const expectation = isExclusive ? 'exactly one' : 'at least one';
-        lines.push(`if (${invalidExpression}) {`, ...indent([
-            `errors.push({ path, keyword: '${keyword}', message: 'Expected ${expectation} matching branch' });`,
-        ]), '}');
-    }
-    #renderStringConstraints(lines, schema) {
-        if (schema.format === null &&
-            schema.maxLength === null &&
-            schema.minLength === null &&
-            schema.pattern === null) {
-            return;
-        }
-        lines.push(`if (typeof value === 'string') {`);
-        const checks = [];
-        if (schema.minLength !== null) {
-            checks.push(`if (Array.from(value).length < ${schema.minLength}) {`, ...indent([
-                `errors.push({ path, keyword: 'minLength', message: 'String is shorter than ${schema.minLength} characters' });`,
-            ]), '}');
-        }
-        if (schema.maxLength !== null) {
-            checks.push(`if (Array.from(value).length > ${schema.maxLength}) {`, ...indent([
-                `errors.push({ path, keyword: 'maxLength', message: 'String is longer than ${schema.maxLength} characters' });`,
-            ]), '}');
-        }
-        if (schema.pattern !== null) {
-            checks.push(`if (!new RegExp(${JSON.stringify(schema.pattern)}, 'u').test(value)) {`, ...indent([
-                `errors.push({ path, keyword: 'pattern', message: 'String does not match the documented pattern' });`,
-            ]), '}');
-        }
-        if (schema.format === 'email') {
-            checks.push(`if (!/^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/u.test(value)) {`, ...indent([
-                `errors.push({ path, keyword: 'format', message: 'Expected email format' });`,
-            ]), '}');
-        }
-        lines.push(...indent(checks), '}');
-    }
-    #renderNumberConstraints(lines, schema) {
-        if (schema.exclusiveMaximum === null &&
-            schema.exclusiveMinimum === null &&
-            schema.maximum === null &&
-            schema.minimum === null) {
-            return;
-        }
-        lines.push(`if (typeof value === 'number' && Number.isFinite(value)) {`);
-        const checks = [];
-        const addCheck = (expression, keyword, message) => {
-            checks.push(`if (${expression}) {`, ...indent([
-                `errors.push({ path, keyword: '${keyword}', message: ${JSON.stringify(message)} });`,
-            ]), '}');
-        };
-        if (schema.minimum !== null) {
-            addCheck(`value < ${schema.minimum}`, 'minimum', `Number must be at least ${schema.minimum}`);
-        }
-        if (schema.maximum !== null) {
-            addCheck(`value > ${schema.maximum}`, 'maximum', `Number must be at most ${schema.maximum}`);
-        }
-        if (schema.exclusiveMinimum !== null) {
-            addCheck(`value <= ${schema.exclusiveMinimum}`, 'exclusiveMinimum', `Number must be greater than ${schema.exclusiveMinimum}`);
-        }
-        if (schema.exclusiveMaximum !== null) {
-            addCheck(`value >= ${schema.exclusiveMaximum}`, 'exclusiveMaximum', `Number must be less than ${schema.exclusiveMaximum}`);
-        }
-        lines.push(...indent(checks), '}');
-    }
-    #renderArrayConstraints(lines, itemValidator) {
-        if (itemValidator === null) {
-            return;
-        }
-        lines.push('if (Array.isArray(value)) {', ...indent([
-            'for (let index = 0; index < value.length; index += 1) {',
-            ...indent(['const item = value[index];']),
-            ...indent([`${itemValidator}(item, [...path, index], errors);`]),
-            '}',
-        ]), '}');
-    }
-    #renderObjectConstraints(lines, schema, children) {
-        if (children.properties.length === 0 &&
-            children.additionalProperties === null &&
-            schema.additionalProperties !== false) {
-            return;
-        }
-        lines.push(`if (typeof value === 'object' && value !== null && !Array.isArray(value)) {`);
-        const checks = [];
-        for (const property of children.properties) {
-            const hasProperty = `Object.prototype.hasOwnProperty.call(value, ${JSON.stringify(property.name)})`;
-            const propertyPath = `[...path, ${JSON.stringify(property.name)}]`;
-            if (property.required) {
-                checks.push(`if (!${hasProperty}) {`, ...indent([
-                    `errors.push({ path: ${propertyPath}, keyword: 'required', message: 'Required property is missing' });`,
-                ]), '} else {', ...indent([
-                    `${property.functionName}(Reflect.get(value, ${JSON.stringify(property.name)}), ${propertyPath}, errors);`,
-                ]), '}');
-            }
-            else {
-                checks.push(`if (${hasProperty}) {`, ...indent([
-                    `${property.functionName}(Reflect.get(value, ${JSON.stringify(property.name)}), ${propertyPath}, errors);`,
-                ]), '}');
-            }
-        }
-        if (schema.additionalProperties === false ||
-            children.additionalProperties !== null) {
-            const propertyNames = children.properties.map(({ name }) => name);
-            checks.push('for (const key of Object.keys(value)) {');
-            const isAdditionalProperty = propertyNames.length === 0
-                ? 'true'
-                : `![${propertyNames
-                    .map((name) => JSON.stringify(name))
-                    .join(', ')}].includes(key)`;
-            const additionalChecks = [`if (${isAdditionalProperty}) {`];
-            if (schema.additionalProperties === false) {
-                additionalChecks.push(...indent([
-                    `errors.push({ path: [...path, key], keyword: 'additionalProperties', message: 'Unknown property is not allowed' });`,
-                ]));
-            }
-            else if (children.additionalProperties !== null) {
-                additionalChecks.push(...indent([
-                    `${children.additionalProperties}(Reflect.get(value, key), [...path, key], errors);`,
-                ]));
-            }
-            additionalChecks.push('}');
-            checks.push(...indent(additionalChecks), '}');
-        }
-        lines.push(...indent(checks), '}');
-    }
 }
 export function emitSchemaMakers(model, config) {
     const files = new Map();

package/dist/src/generator/validations/render-arrays.d.ts

@@ -0,0 +1 @@
+export declare function renderArrayConstraints(lines: string[], itemValidator: string | null): void;

package/dist/src/generator/validations/render-arrays.js

@@ -0,0 +1,5 @@
+export function renderArrayConstraints(lines, itemValidator) {
+    if (itemValidator === null)
+        return;
+    lines.push('if (Array.isArray(value)) {', '  for (let index = 0; index < value.length; index += 1) {', '    const item = value[index];', `    ${itemValidator}(item, [...path, index], errors);`, '  }', '}');
+}

package/dist/src/generator/validations/render-numbers.d.ts

@@ -0,0 +1,2 @@
+import type { StandardSchema } from '../types.js';
+export declare function renderNumberConstraints(lines: string[], schema: StandardSchema): void;

package/dist/src/generator/validations/render-numbers.js

@@ -0,0 +1,24 @@
+import { indent } from './render-utils.js';
+export function renderNumberConstraints(lines, schema) {
+    if (schema.exclusiveMaximum === null &&
+        schema.exclusiveMinimum === null &&
+        schema.maximum === null &&
+        schema.minimum === null)
+        return;
+    lines.push("if (typeof value === 'number' && Number.isFinite(value)) {");
+    const checks = [];
+    const addCheck = (expression, keyword, message) => {
+        checks.push(`if (${expression}) {`, ...indent([
+            `errors.push({ path, keyword: '${keyword}', message: ${JSON.stringify(message)} });`,
+        ]), '}');
+    };
+    if (schema.minimum !== null)
+        addCheck(`value < ${schema.minimum}`, 'minimum', `Number must be at least ${schema.minimum}`);
+    if (schema.maximum !== null)
+        addCheck(`value > ${schema.maximum}`, 'maximum', `Number must be at most ${schema.maximum}`);
+    if (schema.exclusiveMinimum !== null)
+        addCheck(`value <= ${schema.exclusiveMinimum}`, 'exclusiveMinimum', `Number must be greater than ${schema.exclusiveMinimum}`);
+    if (schema.exclusiveMaximum !== null)
+        addCheck(`value >= ${schema.exclusiveMaximum}`, 'exclusiveMaximum', `Number must be less than ${schema.exclusiveMaximum}`);
+    lines.push(...indent(checks), '}');
+}

package/dist/src/generator/validations/render-objects.d.ts

@@ -0,0 +1,3 @@
+import type { StandardSchema } from '../types.js';
+import type { ChildFunctions } from './types.js';
+export declare function renderObjectConstraints(lines: string[], schema: StandardSchema, children: ChildFunctions): void;

package/dist/src/generator/validations/render-objects.js

@@ -0,0 +1,39 @@
+import { indent } from './render-utils.js';
+export function renderObjectConstraints(lines, schema, children) {
+    if (children.properties.length === 0 &&
+        children.additionalProperties === null &&
+        schema.additionalProperties !== false)
+        return;
+    lines.push("if (typeof value === 'object' && value !== null && !Array.isArray(value)) {");
+    const checks = [];
+    for (const property of children.properties) {
+        const hasProperty = `Object.prototype.hasOwnProperty.call(value, ${JSON.stringify(property.name)})`;
+        const propertyPath = `[...path, ${JSON.stringify(property.name)}]`;
+        const validation = `${property.functionName}(Reflect.get(value, ${JSON.stringify(property.name)}), ${propertyPath}, errors);`;
+        if (property.required)
+            checks.push(`if (!${hasProperty}) {`, ...indent([
+                `errors.push({ path: ${propertyPath}, keyword: 'required', message: 'Required property is missing' });`,
+            ]), '} else {', ...indent([validation]), '}');
+        else
+            checks.push(`if (${hasProperty}) {`, ...indent([validation]), '}');
+    }
+    if (schema.additionalProperties === false ||
+        children.additionalProperties !== null) {
+        const propertyNames = children.properties.map(({ name }) => name);
+        const isAdditional = propertyNames.length === 0
+            ? 'true'
+            : `![${propertyNames.map((name) => JSON.stringify(name)).join(', ')}].includes(key)`;
+        const additional = [`if (${isAdditional}) {`];
+        if (schema.additionalProperties === false)
+            additional.push(...indent([
+                `errors.push({ path: [...path, key], keyword: 'additionalProperties', message: 'Unknown property is not allowed' });`,
+            ]));
+        else if (children.additionalProperties !== null)
+            additional.push(...indent([
+                `${children.additionalProperties}(Reflect.get(value, key), [...path, key], errors);`,
+            ]));
+        additional.push('}');
+        checks.push('for (const key of Object.keys(value)) {', ...indent(additional), '}');
+    }
+    lines.push(...indent(checks), '}');
+}

package/dist/src/generator/validations/render-primitives.d.ts

@@ -0,0 +1,3 @@
+import type { JsonPrimitive, SchemaType } from '../types.js';
+export declare function typeExpression(type: SchemaType, value?: string): string;
+export declare function renderPrimitiveConstraints(lines: string[], constValue: JsonPrimitive | undefined, enumValues: readonly JsonPrimitive[] | null): void;

package/dist/src/generator/validations/render-primitives.js

@@ -0,0 +1,36 @@
+import { indent } from './render-utils.js';
+export function typeExpression(type, value = 'value') {
+    switch (type) {
+        case 'array':
+            return `Array.isArray(${value})`;
+        case 'boolean':
+            return `typeof ${value} === 'boolean'`;
+        case 'integer':
+            return `typeof ${value} === 'number' && Number.isFinite(${value}) && Number.isInteger(${value})`;
+        case 'null':
+            return `${value} === null`;
+        case 'number':
+            return `typeof ${value} === 'number' && Number.isFinite(${value})`;
+        case 'object':
+            return `typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value})`;
+        case 'string':
+            return `typeof ${value} === 'string'`;
+        default: {
+            const exhaustive = type;
+            throw new Error(`Unsupported normalised schema type "${exhaustive}"`);
+        }
+    }
+}
+export function renderPrimitiveConstraints(lines, constValue, enumValues) {
+    if (constValue !== undefined) {
+        lines.push(`if (!Object.is(value, ${JSON.stringify(constValue)})) {`, ...indent([
+            `errors.push({ path, keyword: 'const', message: 'Expected the documented constant value' });`,
+        ]), '}');
+    }
+    if (enumValues !== null) {
+        const values = enumValues.map((value) => JSON.stringify(value)).join(', ');
+        lines.push(`if (![${values}].some((candidate) => Object.is(candidate, value))) {`, ...indent([
+            `errors.push({ path, keyword: 'enum', message: 'Expected a documented enum value' });`,
+        ]), '}');
+    }
+}

package/dist/src/generator/validations/render-strings.d.ts

@@ -0,0 +1,2 @@
+import type { StandardSchema } from '../types.js';
+export declare function renderStringConstraints(lines: string[], schema: StandardSchema): void;

package/dist/src/generator/validations/render-strings.js

@@ -0,0 +1,29 @@
+import { indent } from './render-utils.js';
+const EMAIL_FORMAT_PATTERN = "^[A-Za-z0-9!#$%&'*+\\/=?^_`{|}~-]+(?:\\.[A-Za-z0-9!#$%&'*+\\/=?^_`{|}~-]+)*@[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*\\.[A-Za-z]{2,63}$";
+export function renderStringConstraints(lines, schema) {
+    if (schema.format === null &&
+        schema.maxLength === null &&
+        schema.minLength === null &&
+        schema.pattern === null)
+        return;
+    lines.push("if (typeof value === 'string') {");
+    const checks = [];
+    if (schema.minLength !== null)
+        checks.push(`if (Array.from(value).length < ${schema.minLength}) {`, ...indent([
+            `errors.push({ path, keyword: 'minLength', message: 'String is shorter than ${schema.minLength} characters' });`,
+        ]), '}');
+    if (schema.maxLength !== null)
+        checks.push(`if (Array.from(value).length > ${schema.maxLength}) {`, ...indent([
+            `errors.push({ path, keyword: 'maxLength', message: 'String is longer than ${schema.maxLength} characters' });`,
+        ]), '}');
+    if (schema.pattern !== null)
+        checks.push(`if (!new RegExp(${JSON.stringify(schema.pattern)}, 'u').test(value)) {`, ...indent([
+            `errors.push({ path, keyword: 'pattern', message: 'String does not match the documented pattern' });`,
+        ]), '}');
+    if (schema.format === 'email') {
+        checks.push(`if (!new RegExp(${JSON.stringify(EMAIL_FORMAT_PATTERN)}).test(value)) {`, ...indent([
+            `errors.push({ path, keyword: 'format', message: 'Expected email format' });`,
+        ]), '}');
+    }
+    lines.push(...indent(checks), '}');
+}

package/dist/src/generator/validations/render-unions.d.ts

@@ -0,0 +1,2 @@
+export declare function renderAllOf(lines: string[], children: readonly string[]): void;
+export declare function renderUnionConstraint(lines: string[], keyword: 'anyOf' | 'oneOf', branches: readonly string[], isExclusive: boolean): void;

package/dist/src/generator/validations/render-unions.js

@@ -0,0 +1,19 @@
+export function renderAllOf(lines, children) {
+    for (const child of children)
+        lines.push(`${child}(value, path, errors);`);
+}
+export function renderUnionConstraint(lines, keyword, branches, isExclusive) {
+    if (branches.length === 0)
+        return;
+    const variable = `${keyword}Matches`;
+    lines.push(`let ${variable} = 0;`);
+    for (const [index, branch] of branches.entries()) {
+        const errorsName = `${keyword}Errors${index}`;
+        lines.push(`const ${errorsName}: ValidationIssue[] = [];`, `if (${branch}(value, path, ${errorsName})) {`, `  ${variable} += 1;`, '}');
+    }
+    const invalidExpression = isExclusive
+        ? `${variable} !== 1`
+        : `${variable} === 0`;
+    const expectation = isExclusive ? 'exactly one' : 'at least one';
+    lines.push(`if (${invalidExpression}) {`, `  errors.push({ path, keyword: '${keyword}', message: 'Expected ${expectation} matching branch' });`, '}');
+}

package/dist/src/generator/validations/render-utils.d.ts

@@ -0,0 +1 @@
+export declare function indent(lines: readonly string[], spaces?: number): string[];

package/dist/src/generator/validations/render-utils.js

@@ -0,0 +1,4 @@
+export function indent(lines, spaces = 2) {
+    const prefix = ' '.repeat(spaces);
+    return lines.map((line) => (line.length === 0 ? line : `${prefix}${line}`));
+}

package/dist/src/generator/validations/types.d.ts

@@ -0,0 +1,12 @@
+import type { SchemaProperty } from '../types.js';
+export type ChildFunctions = {
+    readonly additionalProperties: string | null;
+    readonly allOf: readonly string[];
+    readonly anyOf: readonly string[];
+    readonly items: string | null;
+    readonly oneOf: readonly string[];
+    readonly properties: readonly (SchemaProperty & {
+        readonly functionName: string;
+    })[];
+    readonly reference: string | null;
+};

package/dist/src/generator/validations/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "openapi-contract-kit",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Generate type-safe TypeScript contracts and runtime validators from JSON OpenAPI 3.1 documents.",
   "type": "module",
   "license": "MIT",
   "engines": {
-    "node": ">=26"
+    "node": ">=24.0.0"
   },
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
@@ -32,7 +32,7 @@
   ],
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@types/node": "^26.5.1",
+    "@types/node": "^24.0.0",
     "eslint": "^10.10.0",
     "prettier": "^3.9.6",
     "typescript": "^5.9.3",