openapi-contract-kit 0.0.1 → 0.0.3

package/dist/src/generator/emitMakers.js

@@ -0,0 +1,328 @@
+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}"`);
+        }
+    }
+}
+class MakerRenderer {
+    #counter = 0;
+    #functions = [];
+    #nodeNames = new WeakMap();
+    #nodeSignatures = new Map();
+    #referencedSchemas = new Set();
+    #schemaNames;
+    constructor(model) {
+        this.#schemaNames = new Set(model.schemas.map(({ name }) => name));
+    }
+    render(name, schema, runtimeImport) {
+        const rootValidator = this.#emitNode(schema);
+        const makerImports = [...this.#referencedSchemas]
+            .sort()
+            .map((reference) => `import { make${reference} } from './${reference}';`)
+            .join('\n');
+        return `/**
+ * Generated by openapi-contract-kit.
+ * Do not edit directly.
+ */
+
+import type { Result, ValidationIssue, ValidationPath } from ${JSON.stringify(runtimeImport)};
+import type { ${name} } from '../quickpay-api';
+${makerImports}${makerImports.length > 0 ? '\n' : ''}
+
+${this.#functions.join('\n\n')}
+
+function validate${name}(
+  value: unknown,
+  path: ValidationPath,
+  errors: ValidationIssue[]
+): value is ${name} {
+  return ${rootValidator}(value, path, errors);
+}
+
+export function make${name}(input: unknown): Result<${name}> {
+  const errors: ValidationIssue[] = [];
+
+  if (!validate${name}(input, [], errors)) {
+    return { ok: false, errors };
+  }
+
+  return { ok: true, value: input };
+}
+`;
+    }
+    #emitNode(schema) {
+        const existing = this.#nodeNames.get(schema);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const signature = JSON.stringify(schema, (key, value) => key === 'location' ? undefined : value);
+        const matchingNode = this.#nodeSignatures.get(signature);
+        if (matchingNode !== undefined) {
+            this.#nodeNames.set(schema, matchingNode);
+            return matchingNode;
+        }
+        const functionName = `validateNode${this.#counter}`;
+        this.#counter += 1;
+        this.#nodeNames.set(schema, functionName);
+        this.#nodeSignatures.set(signature, functionName);
+        const childFunctions = this.#createChildFunctions(schema);
+        const body = this.#renderNodeBody(schema, childFunctions);
+        this.#functions.push(`function ${functionName}(\n  value: unknown,\n  path: ValidationPath,\n  errors: ValidationIssue[]\n): boolean {\n${indent(body).join('\n')}\n}`);
+        return functionName;
+    }
+    #createChildFunctions(schema) {
+        if (schema.booleanSchema !== null) {
+            return {
+                additionalProperties: null,
+                allOf: [],
+                anyOf: [],
+                items: null,
+                oneOf: [],
+                properties: [],
+                reference: null,
+            };
+        }
+        return {
+            additionalProperties: typeof schema.additionalProperties === 'boolean'
+                ? null
+                : this.#emitNode(schema.additionalProperties),
+            allOf: schema.allOf.map((child) => this.#emitNode(child)),
+            anyOf: schema.anyOf.map((child) => this.#emitNode(child)),
+            items: schema.items === null ? null : this.#emitNode(schema.items),
+            oneOf: schema.oneOf.map((child) => this.#emitNode(child)),
+            properties: schema.properties.map((property) => ({
+                ...property,
+                functionName: this.#emitNode(property.schema),
+            })),
+            reference: schema.reference === null
+                ? null
+                : this.#registerReference(schema.reference),
+        };
+    }
+    #registerReference(reference) {
+        if (!this.#schemaNames.has(reference)) {
+            throw new Error(`Unknown schema model reference "${reference}"`);
+        }
+        this.#referencedSchemas.add(reference);
+        return reference;
+    }
+    #renderNodeBody(schema, children) {
+        const lines = ['const errorCount = errors.length;'];
+        if (schema.booleanSchema !== null) {
+            if (schema.booleanSchema) {
+                lines.push('return true;');
+            }
+            else {
+                lines.push(`errors.push({ path, keyword: 'falseSchema', message: 'Value is not allowed' });`, 'return false;');
+            }
+            return lines;
+        }
+        if (children.reference !== null) {
+            lines.push(`const referenceResult = make${children.reference}(value);`, `if (!referenceResult.ok) {`, ...indent([
+                `for (const issue of referenceResult.errors) {`,
+                ...indent([
+                    `errors.push({ ...issue, path: [...path, ...issue.path] });`,
+                ]),
+                `}`,
+            ]), `}`);
+        }
+        if (schema.types !== null) {
+            const expected = schema.types
+                .map((type) => typeExpression(type))
+                .join(' || ');
+            lines.push(`if (!(${expected})) {`, ...indent([
+                `errors.push({ path, keyword: 'type', message: ${JSON.stringify(`Expected ${schema.types.join(' or ')}`)} });`,
+                '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);
+        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();
+    for (const { name, schema } of model.schemas) {
+        const renderer = new MakerRenderer(model);
+        files.set(`schemas/${name}.ts`, renderer.render(name, schema, config.runtimeImport));
+    }
+    return files;
+}

package/dist/src/generator/emitTypes.d.ts

@@ -0,0 +1,3 @@
+import type { NormalizedSchema, OpenApiModel } from './types.js';
+export declare function renderSchemaType(schema: NormalizedSchema): string;
+export declare function emitRootTypes(model: OpenApiModel): string;

package/dist/src/generator/emitTypes.js

@@ -0,0 +1,87 @@
+function renderLiteral(value) {
+    return JSON.stringify(value);
+}
+function parenthesise(type) {
+    return type.includes(' | ') || type.includes(' & ') ? `(${type})` : type;
+}
+function renderObjectType(schema) {
+    if (schema.properties.length === 0) {
+        if (typeof schema.additionalProperties !== 'boolean') {
+            return `Record<string, ${renderSchemaType(schema.additionalProperties)}>`;
+        }
+        return 'Record<string, unknown>';
+    }
+    const properties = schema.properties.map((property) => {
+        const optional = property.required ? '' : '?';
+        return `  ${JSON.stringify(property.name)}${optional}: ${renderSchemaType(property.schema)};`;
+    });
+    return `{\n${properties.join('\n')}\n}`;
+}
+function renderBasicType(type, schema) {
+    switch (type) {
+        case 'array': {
+            const itemType = schema.items === null ? 'unknown' : renderSchemaType(schema.items);
+            return `Array<${itemType}>`;
+        }
+        case 'boolean':
+            return 'boolean';
+        case 'integer':
+        case 'number':
+            return 'number';
+        case 'null':
+            return 'null';
+        case 'object':
+            return renderObjectType(schema);
+        case 'string':
+            return 'string';
+        default: {
+            const exhaustive = type;
+            throw new Error(`Unsupported normalised schema type "${exhaustive}"`);
+        }
+    }
+}
+export function renderSchemaType(schema) {
+    if (schema.booleanSchema !== null) {
+        return schema.booleanSchema ? 'unknown' : 'never';
+    }
+    const intersections = [];
+    if (schema.reference !== null) {
+        intersections.push(schema.reference);
+    }
+    if (schema.constValue !== undefined) {
+        intersections.push(renderLiteral(schema.constValue));
+    }
+    else if (schema.enumValues !== null) {
+        intersections.push(schema.enumValues.map(renderLiteral).join(' | '));
+    }
+    else if (schema.types !== null) {
+        intersections.push(schema.types.map((type) => renderBasicType(type, schema)).join(' | '));
+    }
+    for (const child of schema.allOf) {
+        intersections.push(renderSchemaType(child));
+    }
+    if (schema.oneOf.length > 0) {
+        intersections.push(schema.oneOf.map(renderSchemaType).join(' | '));
+    }
+    if (schema.anyOf.length > 0) {
+        intersections.push(schema.anyOf.map(renderSchemaType).join(' | '));
+    }
+    const meaningful = intersections.filter((type) => type !== 'unknown');
+    if (meaningful.length === 0) {
+        return 'unknown';
+    }
+    return meaningful.map(parenthesise).join(' & ');
+}
+export function emitRootTypes(model) {
+    const declarations = model.schemas.flatMap(({ name, schema }) => [
+        `export type ${name} = ${renderSchemaType(schema)};`,
+        `export type ShapeOf${name} = ${name};`,
+    ]);
+    return `/**
+ * Generated by openapi-contract-kit.
+ * Do not edit directly.
+ */
+
+${declarations.join('\n\n')}
+`;
+}

package/dist/src/generator/generateOpenApiRuntime.d.ts

@@ -0,0 +1,3 @@
+import type { GenerateOpenApiRuntimeOptions, GenerateOpenApiRuntimeResult } from './types.js';
+export declare function generateOpenApiRuntime(options?: GenerateOpenApiRuntimeOptions): Promise<GenerateOpenApiRuntimeResult>;
+export declare function main(argv?: readonly string[]): Promise<void>;

package/dist/src/generator/generateOpenApiRuntime.js

@@ -0,0 +1,41 @@
+import { fileURLToPath } from 'node:url';
+import { formatFailureOutput, formatSuccessOutput, } from '../cli/formatOutput.js';
+import { resolveGeneratorConfig } from './config.js';
+import { emitEndpointModules } from './emitEndpoints.js';
+import { emitSchemaMakers } from './emitMakers.js';
+import { emitRootTypes } from './emitTypes.js';
+import { buildOpenApiModel } from './model.js';
+import { writeGeneratedOutput } from './writeOutput.js';
+export async function generateOpenApiRuntime(options = {}) {
+    const argv = options.argv ?? [];
+    const cwd = options.cwd ?? process.cwd();
+    const config = await resolveGeneratorConfig({ argv, cwd });
+    const model = await buildOpenApiModel(config.specPath);
+    const files = new Map([
+        ['quickpay-api.ts', emitRootTypes(model)],
+        ...emitSchemaMakers(model, config),
+        ...emitEndpointModules(model, config),
+    ]);
+    await writeGeneratedOutput(config.outDir, files, {
+        protectedPaths: [config.configPath, config.specPath],
+    });
+    return {
+        operationCount: model.operations.length,
+        operationNames: model.operations.map(({ name }) => name),
+        schemaCount: model.schemas.length,
+    };
+}
+export async function main(argv = process.argv.slice(2)) {
+    try {
+        const result = await generateOpenApiRuntime({ argv });
+        process.stdout.write(formatSuccessOutput(result, process.stdout));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(formatFailureOutput(message, process.stderr));
+        process.exitCode = 1;
+    }
+}
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    await main();
+}

package/dist/src/generator/model.d.ts

@@ -0,0 +1,2 @@
+import type { OpenApiModel } from './types.js';
+export declare function buildOpenApiModel(specPath: string): Promise<OpenApiModel>;