openapi-contract-kit 0.0.1 → 0.0.4

package/src/generator/emitMakers.mjs

@@ -1,459 +0,0 @@
-import { join } from 'node:path';
-
-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:
-      throw new Error(`Unsupported normalised schema type "${type}"`);
-  }
-}
-
-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 = {
-      additionalProperties:
-        schema.additionalProperties !== true &&
-        schema.additionalProperties !== false &&
-        schema.additionalProperties !== undefined
-          ? this.#emitNode(schema.additionalProperties)
-          : null,
-      allOf: (schema.allOf ?? []).map((child) => this.#emitNode(child)),
-      anyOf: (schema.anyOf ?? []).map((child) => this.#emitNode(child)),
-      items:
-        schema.items !== null && schema.items !== undefined
-          ? this.#emitNode(schema.items)
-          : null,
-      oneOf: (schema.oneOf ?? []).map((child) => this.#emitNode(child)),
-      properties: (schema.properties ?? []).map((property) => ({
-        ...property,
-        functionName: this.#emitNode(property.schema),
-      })),
-      reference:
-        schema.reference !== null && schema.reference !== undefined
-          ? this.#registerReference(schema.reference)
-          : null,
-    };
-    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;
-  }
-
-  #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 === false) {
-      lines.push(
-        `errors.push({ path, keyword: 'falseSchema', message: 'Value is not allowed' });`,
-        'return false;'
-      );
-      return lines;
-    }
-    if (schema.booleanSchema === true) {
-      lines.push('return true;');
-      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 (const [index, item] of value.entries()) {',
-        ...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 {
-        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, { outDir, runtimeImport }) {
-  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, runtimeImport)
-    );
-  }
-
-  return files;
-}

package/src/generator/emitTypes.mjs

@@ -1,104 +0,0 @@
-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 (
-      schema.additionalProperties !== true &&
-      schema.additionalProperties !== false
-    ) {
-      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:
-      throw new Error(`Unsupported normalised schema type "${type}"`);
-  }
-}
-
-export function renderSchemaType(schema) {
-  if (schema.booleanSchema === false) {
-    return 'never';
-  }
-  if (schema.booleanSchema === true) {
-    return 'unknown';
-  }
-
-  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/src/generator/generateOpenApiRuntime.mjs

@@ -1,48 +0,0 @@
-import { fileURLToPath } from 'node:url';
-
-import { resolveGeneratorConfig } from './config.mjs';
-import { emitEndpointModules } from './emitEndpoints.mjs';
-import { emitSchemaMakers } from './emitMakers.mjs';
-import { emitRootTypes } from './emitTypes.mjs';
-import { buildOpenApiModel } from './model.mjs';
-import { writeGeneratedOutput } from './writeOutput.mjs';
-
-export async function generateOpenApiRuntime({
-  argv = [],
-  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(
-      `Generated ${result.schemaCount} schemas and ${result.operationCount} endpoints.\n`
-    );
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    process.stderr.write(`OpenAPI generation failed: ${message}\n`);
-    process.exitCode = 1;
-  }
-}
-
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  await main();
-}