@amritk/generate-validators 0.5.1 → 0.7.0

package/src/generators/build-schema.test.ts

@@ -1,163 +0,0 @@
-import { validate } from '@scalar/openapi-parser'
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12'
-import { describe, expect, it } from 'vitest'
-
-import { buildValidatorSchema } from './build-schema'
-
-describe('build-schema', () => {
-  it('generates a validator file for the root schema', async () => {
-    const schema: JSONSchema = {
-      type: 'object',
-      properties: { title: { type: 'string' } },
-      required: ['title'],
-    }
-
-    const files = await buildValidatorSchema(schema, 'Document')
-    const filenames = files.map((f) => f.filename)
-
-    expect(filenames).toContain('document.ts')
-    expect(filenames).toContain('validation-result.ts')
-    expect(filenames).toContain('index.ts')
-  })
-
-  it('generates a file per $ref definition', async () => {
-    const schema: JSONSchema = {
-      type: 'object',
-      properties: {
-        info: { $ref: '#/$defs/info' },
-      },
-      $defs: {
-        info: {
-          type: 'object',
-          properties: { title: { type: 'string' } },
-          required: ['title'],
-        },
-      },
-    }
-
-    const files = await buildValidatorSchema(schema, 'Document')
-    const filenames = files.map((f) => f.filename)
-
-    expect(filenames).toContain('document.ts')
-    expect(filenames).toContain('info.ts')
-  })
-
-  it('generated document.ts exports a validateDocument function', async () => {
-    const schema: JSONSchema = {
-      type: 'object',
-      properties: { title: { type: 'string' } },
-      required: ['title'],
-    }
-
-    const files = await buildValidatorSchema(schema, 'Document')
-    const documentFile = files.find((f) => f.filename === 'document.ts')
-
-    expect(documentFile?.content).toContain('export const validateDocument')
-    expect(documentFile?.content).toContain('ValidationResult')
-  })
-
-  it('generated file imports the ref validator for $ref properties', async () => {
-    const schema: JSONSchema = {
-      type: 'object',
-      properties: {
-        info: { $ref: '#/$defs/info' },
-      },
-      $defs: {
-        info: {
-          type: 'object',
-          properties: { title: { type: 'string' } },
-        },
-      },
-    }
-
-    const files = await buildValidatorSchema(schema, 'Document')
-    const documentFile = files.find((f) => f.filename === 'document.ts')
-
-    expect(documentFile?.content).toContain("from './info'")
-    expect(documentFile?.content).toContain('validateInfo')
-  })
-
-  it('generates a valid index.ts with re-exports', async () => {
-    const schema: JSONSchema = {
-      type: 'object',
-      properties: { title: { type: 'string' } },
-    }
-
-    const files = await buildValidatorSchema(schema, 'Document')
-    const indexFile = files.find((f) => f.filename === 'index.ts')
-
-    expect(indexFile?.content).toContain("from './document'")
-    expect(indexFile?.content).toContain('validateDocument')
-  })
-
-  it('does not generate a file named validation-result for a schema ref', async () => {
-    const schema: JSONSchema = {
-      type: 'object',
-      properties: {
-        result: { $ref: '#/$defs/validation-result' },
-      },
-      $defs: {
-        'validation-result': { type: 'object' },
-      },
-    }
-
-    const files = await buildValidatorSchema(schema, 'Document')
-    // Should still have exactly one validation-result.ts (the runtime contract)
-    const vrFiles = files.filter((f) => f.filename === 'validation-result.ts')
-    expect(vrFiles).toHaveLength(1)
-    expect(vrFiles[0]?.content).toContain('export type ValidationResult')
-  })
-
-  it('produces generated validators that agree with @scalar/openapi-parser on a valid document', async () => {
-    // Build validators for a minimal OpenAPI-like schema
-    const schema: JSONSchema = {
-      type: 'object',
-      properties: {
-        openapi: { type: 'string' },
-        info: { $ref: '#/$defs/info' },
-      },
-      required: ['openapi', 'info'],
-      $defs: {
-        info: {
-          type: 'object',
-          properties: {
-            title: { type: 'string' },
-            version: { type: 'string' },
-          },
-          required: ['title', 'version'],
-        },
-      },
-    }
-
-    const files = await buildValidatorSchema(schema, 'Document')
-
-    // Sanity-check generated code shape
-    const documentFile = files.find((f) => f.filename === 'document.ts')
-    const infoFile = files.find((f) => f.filename === 'info.ts')
-
-    expect(documentFile?.content).toContain('validateDocument')
-    expect(infoFile?.content).toContain('validateInfo')
-
-    // Cross-check: @scalar/openapi-parser says a complete document is valid
-    const validDoc = { openapi: '3.1.0', info: { title: 'API', version: '1.0' }, paths: {} }
-    const refResult = await validate(validDoc)
-    expect(refResult.valid).toBe(true)
-
-    // Cross-check: @scalar/openapi-parser says a document missing info.title is invalid
-    const invalidDoc = { openapi: '3.1.0', info: { version: '1.0' }, paths: {} }
-    const refInvalid = await validate(invalidDoc)
-    expect(refInvalid.valid).toBe(false)
-    expect(refInvalid.errors.some((e) => e.message.includes('title'))).toBe(true)
-  })
-
-  it('emits a validation-result.ts with the runtime ValidationResult/ValidationError types', async () => {
-    const schema: JSONSchema = { type: 'object' }
-    const files = await buildValidatorSchema(schema, 'Doc')
-    const vrFile = files.find((f) => f.filename === 'validation-result.ts')
-
-    expect(vrFile?.content).toContain('export type ValidationError')
-    expect(vrFile?.content).toContain('export type ValidationResult')
-    expect(vrFile?.content).toContain('message: string')
-    expect(vrFile?.content).toContain('path: string')
-  })
-})

package/src/generators/build-schema.ts

@@ -1,81 +0,0 @@
-import { generateIndexBarrel } from '@amritk/helpers/generate-index-barrel'
-import { walkRefGraph } from '@amritk/helpers/walk-ref-graph'
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12'
-
-import { generateValidatorFile } from './generate-files'
-
-/**
- * Represents a generated TypeScript file with its filename and content.
- */
-export type GeneratedFile = {
-  filename: string
-  content: string
-}
-
-const VALIDATION_RESULT_CONTENT = `/**
- * A single validation error with a human-readable message and a JSON Pointer
- * path indicating where in the document the error occurred.
- */
-export type ValidationError = {
-  message: string
-  path: string
-}
-
-/**
- * The result of a generated validator function.
- * Returns \`true\` when the input is valid, or an object with \`valid: false\`
- * and a list of errors when it is not.
- */
-export type ValidationResult = true | { valid: false; errors: ValidationError[] }
-`
-
-/**
- * Builds all TypeScript validator files from a JSON Schema by traversing all
- * `$ref` / `$dynamicRef` references recursively (via the shared
- * `@amritk/helpers/walk-ref-graph` walker).
- *
- * Each generated file exports:
- * - A TypeScript type definition
- * - A `validateFoo(input: unknown, _path?: string): ValidationResult` function
- *
- * A `validation-result.ts` file containing the `ValidationResult` and `ValidationError`
- * runtime contract is always emitted. An `index.ts` re-exports everything.
- *
- * @param rootSchema - The root JSON Schema to build from
- * @param rootTypeName - The name for the root type (e.g. "Document")
- * @returns An array of generated TypeScript files
- *
- * @example
- * ```typescript
- * const files = await buildValidatorSchema(schema, 'Document')
- * // files → [{ filename: 'document.ts', content: '...' }, { filename: 'info.ts', ... }, ...]
- * ```
- */
-export const buildValidatorSchema = async (
-  rootSchema: JSONSchema,
-  rootTypeName: string,
-  typeSuffix = '',
-): Promise<GeneratedFile[]> => {
-  const files: GeneratedFile[] = []
-
-  walkRefGraph(rootSchema, rootTypeName, { typeSuffix }, (node) => {
-    // `validation-result` and `index` are reserved output filenames, so never
-    // let a definition of either name overwrite them.
-    if (node.filename === 'validation-result' || node.filename === 'index') return
-
-    const content = generateValidatorFile(node.schema, node.typeName, {
-      rootSchema: node.rootSchema,
-      typeSuffix,
-      ...(node.ref !== undefined ? { selfRef: node.ref } : {}),
-    })
-    files.push({ filename: `${node.filename}.ts`, content })
-  })
-
-  // Emit the runtime contract for validators. ValidationResult is mjst-defined
-  // (not derived from the input schema), so its content is fixed.
-  files.push({ filename: 'validation-result.ts', content: VALIDATION_RESULT_CONTENT })
-
-  files.push({ filename: 'index.ts', content: generateIndexBarrel(files) })
-
-  return files
-}

package/src/generators/collect-validator-imports.ts

@@ -1,134 +0,0 @@
-import { refToFilename } from '@amritk/helpers/ref-to-filename'
-import { refToName } from '@amritk/helpers/ref-to-name'
-import { resolveRef } from '@amritk/helpers/resolve-ref'
-import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasItems, hasOneOf, hasRef } from '@amritk/helpers/schema-guards'
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12'
-
-/**
- * Options for controlling how validator imports are collected.
- */
-type CollectValidatorImportsOptions = {
-  /**
-   * The $ref path of the schema being generated (e.g. `#/$defs/encoding`).
-   * Prevents a file from importing itself.
-   */
-  readonly selfRef?: string | undefined
-  /**
-   * The root schema document. URI refs that cannot be resolved within it
-   * are excluded from the import list (they were never generated as files).
-   */
-  readonly rootSchema?: Record<string, unknown> | undefined
-  /**
-   * Suffix appended to every type/validator name derived from a `$ref`. Must
-   * match the suffix used when generating the referenced files. Defaults to `''`.
-   */
-  readonly typeSuffix?: string
-}
-
-/**
- * Generates an import statement for a single $ref, importing both the type
- * and the validator function from the ref's generated file.
- */
-const buildImport = (ref: string, suffix: string): string => {
-  const filename = refToFilename(ref)
-  const typeName = refToName(ref, suffix)
-  const validatorName = `validate${typeName}`
-  return `import { type ${typeName}, ${validatorName} } from './${filename}'`
-}
-
-/**
- * Resolves the canonical filename for a ref, stripping `-or-reference` suffixes
- * so that `#/$defs/parameter-or-reference` maps to `parameter`.
- */
-const canonicalFilename = (ref: string): string => {
-  const base = ref.endsWith('-or-reference') ? ref.replace('-or-reference', '') : ref
-  return refToFilename(base)
-}
-
-/**
- * Walks one level of the schema and yields all direct $ref strings that should
- * become imports: properties, additionalProperties, items, and union branches.
- */
-const collectDirectRefs = (schema: JSONSchema): string[] => {
-  if (typeof schema === 'boolean' || schema === null) return []
-
-  const refs: string[] = []
-
-  if (hasRef(schema)) {
-    refs.push(schema.$ref)
-    return refs
-  }
-
-  const propSchemas =
-    'properties' in schema && typeof schema.properties === 'object' && schema.properties !== null
-      ? Object.values(schema.properties as Record<string, JSONSchema>)
-      : []
-
-  for (const prop of propSchemas) {
-    if (hasRef(prop)) refs.push((prop as { $ref: string }).$ref)
-    if (hasItems(prop) && hasRef(prop.items)) refs.push((prop.items as { $ref: string }).$ref)
-    if (hasAdditionalProperties(prop) && hasRef(prop.additionalProperties as JSONSchema)) {
-      refs.push((prop.additionalProperties as { $ref: string }).$ref)
-    }
-  }
-
-  if (hasItems(schema) && hasRef(schema.items)) {
-    refs.push((schema.items as { $ref: string }).$ref)
-  }
-
-  if (hasAdditionalProperties(schema) && hasRef(schema.additionalProperties as JSONSchema)) {
-    refs.push((schema.additionalProperties as { $ref: string }).$ref)
-  }
-
-  for (const branch of [
-    ...(hasOneOf(schema) ? schema.oneOf : []),
-    ...(hasAnyOf(schema) ? schema.anyOf : []),
-    ...(hasAllOf(schema) ? schema.allOf : []),
-  ]) {
-    if (hasRef(branch)) refs.push((branch as { $ref: string }).$ref)
-  }
-
-  return refs
-}
-
-/**
- * Collects import statements for all $ref dependencies of a schema.
- * Each import brings in both the generated TypeScript type and validator function.
- *
- * @example
- * ```typescript
- * const schema = { properties: { contact: { $ref: '#/$defs/contact' } } }
- * collectValidatorImports(schema)
- * // ["import { type Contact, validateContact } from './contact'"]
- * ```
- */
-export const collectValidatorImports = (schema: JSONSchema, options?: CollectValidatorImportsOptions): string[] => {
-  const selfFilename = options?.selfRef ? refToFilename(options.selfRef) : null
-  const rootSchema = options?.rootSchema
-  const typeSuffix = options?.typeSuffix ?? ''
-
-  const refs = collectDirectRefs(schema)
-  const seen = new Set<string>()
-  const imports: string[] = []
-
-  for (const ref of refs) {
-    const filename = canonicalFilename(ref)
-
-    if (seen.has(filename)) continue
-    if (selfFilename && filename === selfFilename) continue
-
-    // Skip refs that don't resolve in this schema (external / never generated)
-    if (rootSchema) {
-      const resolved = resolveRef(ref, rootSchema)
-      if (!resolved) continue
-    }
-
-    seen.add(filename)
-
-    // -or-reference unions import the base type's validator
-    const importRef = ref.endsWith('-or-reference') ? ref.replace('-or-reference', '') : ref
-    imports.push(buildImport(importRef, typeSuffix))
-  }
-
-  return imports
-}

package/src/generators/generate-files.ts

@@ -1,79 +0,0 @@
-import { generateTypeDefinition } from '@amritk/helpers/generate-type-definition'
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12'
-
-import { collectValidatorImports } from './collect-validator-imports'
-import { generateValidatorFunction } from './generate-validator-function'
-
-/**
- * Options for controlling what gets generated in a validator file.
- */
-type GenerateValidatorFileOptions = {
-  /**
-   * The $ref path of the schema being generated (e.g. `#/$defs/info`).
-   * Prevents the file from importing itself.
-   */
-  readonly selfRef?: string
-  /**
-   * The root schema document. Used to filter out unresolvable refs.
-   */
-  readonly rootSchema?: Record<string, unknown>
-  /**
-   * Suffix appended to every type/validator name derived from a `$ref`.
-   * Defaults to `''` (no suffix).
-   */
-  readonly typeSuffix?: string
-}
-
-/**
- * Generates a complete TypeScript validator file from a JSON Schema.
- *
- * The file contains:
- * - Imports for the ValidationResult/ValidationError types
- * - Imports for any $ref types and their validator functions
- * - The exported TypeScript type definition
- * - The exported validator function
- *
- * @example
- * ```typescript
- * const schema = {
- *   type: 'object',
- *   properties: { title: { type: 'string' } },
- *   required: ['title'],
- * }
- * generateValidatorFile(schema, 'Info')
- * // import type { ValidationResult, ValidationError } from './validation-result'
- * // export type Info = { title: string }
- * // export const validateInfo = (input: unknown, _path = ''): ValidationResult => { ... }
- * ```
- */
-export const generateValidatorFile = (
-  schema: JSONSchema,
-  typeName: string,
-  options?: GenerateValidatorFileOptions,
-): string => {
-  const typeSuffix = options?.typeSuffix ?? ''
-  const refImports = collectValidatorImports(schema, {
-    selfRef: options?.selfRef,
-    rootSchema: options?.rootSchema,
-    typeSuffix,
-  })
-
-  const typeDefinition = generateTypeDefinition(schema, typeName, { typeSuffix })
-  const validatorFunction = generateValidatorFunction(schema, typeName, typeSuffix)
-
-  let result = `import type { ValidationResult, ValidationError } from './validation-result'\n`
-
-  for (const imp of refImports) {
-    result += imp + '\n'
-  }
-
-  if (refImports.length > 0) {
-    result += '\n'
-  } else {
-    result += '\n'
-  }
-
-  result += typeDefinition + '\n\n' + validatorFunction
-
-  return result
-}

package/src/generators/generate-validator-function.test.ts

@@ -1,238 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { generateValidatorFunction } from './generate-validator-function'
-
-// Eval helper: compiles a generated function string in context of a minimal
-// ValidationResult runtime so we can actually run the generated code.
-const _evalValidator = (code: string): ((input: unknown, path?: string) => unknown) => {
-  const _wrapped = `
-    const ValidationResult = null // type-only
-    ${code}
-  `
-  // eslint-disable-next-line no-new-func
-  return new Function(`
-    ${code}
-    return validate${code.match(/export const validate(\w+)/)?.[1] ?? ''}
-  `)() as (input: unknown, path?: string) => unknown
-}
-
-describe('generate-validator-function', () => {
-  it('generates a validator for a required string property', () => {
-    const schema = {
-      type: 'object' as const,
-      properties: { name: { type: 'string' as const } },
-      required: ['name'],
-    }
-    const code = generateValidatorFunction(schema, 'Info')
-
-    expect(code).toContain('export const validateInfo')
-    expect(code).toContain('"name" in obj')
-    expect(code).toContain("must have required property 'name'")
-    expect(code).toContain('typeof obj["name"] !== \'string\'')
-    expect(code).toContain('must be string')
-  })
-
-  it('generates a validator for an optional number property', () => {
-    const schema = {
-      type: 'object' as const,
-      properties: { count: { type: 'number' as const } },
-    }
-    const code = generateValidatorFunction(schema, 'Stats')
-
-    expect(code).toContain('obj["count"] !== undefined')
-    expect(code).toContain('typeof obj["count"] !== \'number\'')
-    expect(code).toContain('must be number')
-  })
-
-  it('generates a validator for a boolean property', () => {
-    const schema = {
-      type: 'object' as const,
-      properties: { enabled: { type: 'boolean' as const } },
-      required: ['enabled'],
-    }
-    const code = generateValidatorFunction(schema, 'Config')
-
-    expect(code).toContain('typeof obj["enabled"] !== \'boolean\'')
-    expect(code).toContain('must be boolean')
-  })
-
-  it('generates required-property check at parent path', () => {
-    const schema = {
-      type: 'object' as const,
-      properties: { title: { type: 'string' as const } },
-      required: ['title'],
-    }
-    const code = generateValidatorFunction(schema, 'Doc')
-
-    // Required errors use _path (parent), not a child path
-    expect(code).toContain('path: _path')
-    expect(code).toContain("must have required property 'title'")
-  })
-
-  it('generates type error at child path', () => {
-    const schema = {
-      type: 'object' as const,
-      properties: { title: { type: 'string' as const } },
-      required: ['title'],
-    }
-    const code = generateValidatorFunction(schema, 'Doc')
-
-    // Type errors use the child path
-    expect(code).toContain('`${_path}/title`')
-  })
-
-  it('generates an enum validator', () => {
-    const schema = {
-      enum: ['get', 'post', 'put', 'delete'],
-    }
-    const code = generateValidatorFunction(schema as Parameters<typeof generateValidatorFunction>[0], 'Method')
-
-    expect(code).toContain('must be one of')
-    expect(code).toContain('"get"')
-    expect(code).toContain('"post"')
-  })
-
-  it('generates a string pattern check', () => {
-    const schema = {
-      type: 'object' as const,
-      properties: { version: { type: 'string' as const, pattern: '^\\d+\\.\\d+' } },
-      required: ['version'],
-    }
-    const code = generateValidatorFunction(schema, 'Info')
-
-    expect(code).toContain('must match pattern')
-    expect(code).toContain('.test(')
-  })
-
-  it('generates min/maxLength checks', () => {
-    const schema = {
-      type: 'object' as const,
-      properties: { name: { type: 'string' as const, minLength: 1, maxLength: 100 } },
-      required: ['name'],
-    }
-    const code = generateValidatorFunction(schema, 'Info')
-
-    expect(code).toContain('must have at least 1 characters')
-    expect(code).toContain('must have at most 100 characters')
-  })
-
-  it('generates minimum/maximum checks', () => {
-    const schema = {
-      type: 'object' as const,
-      properties: { port: { type: 'number' as const, minimum: 0, maximum: 65535 } },
-    }
-    const code = generateValidatorFunction(schema, 'Server')
-
-    expect(code).toContain('>= 0')
-    expect(code).toContain('<= 65535')
-  })
-
-  it('generates a $ref property delegation', () => {
-    const schema = {
-      type: 'object' as const,
-      properties: { info: { $ref: '#/$defs/info' } },
-      required: ['info'],
-    }
-    const code = generateValidatorFunction(schema, 'Document')
-
-    expect(code).toContain('validateInfo(')
-    expect(code).toContain('"info" in obj')
-  })
-
-  it('generates a scalar string validator', () => {
-    const schema = { type: 'string' as const }
-    const code = generateValidatorFunction(schema, 'StringValue')
-
-    expect(code).toContain("typeof input !== 'string'")
-    expect(code).toContain('must be string')
-  })
-
-  it('accumulates all constraint errors for a scalar string schema', () => {
-    const schema = { type: 'string' as const, pattern: '^\\d+$', minLength: 2, maxLength: 4 }
-    const code = generateValidatorFunction(schema, 'Code')
-
-    // All three constraints push onto a shared errors array instead of returning early
-    expect(code).toContain('const errors: ValidationError[] = []')
-    expect(code).toContain("errors.push({ message: 'must match pattern")
-    expect(code).toContain("errors.push({ message: 'must have at least 2 characters'")
-    expect(code).toContain("errors.push({ message: 'must have at most 4 characters'")
-    expect(code).toContain('return errors.length > 0 ? { valid: false, errors } : true')
-  })
-
-  it('returns true for empty object schemas', () => {
-    const schema = { type: 'object' as const }
-    const code = generateValidatorFunction(schema, 'Empty')
-
-    expect(code).toContain('validateEmpty')
-    expect(code).toContain('must be object')
-    expect(code).toContain('return errors.length > 0')
-  })
-
-  it('generates object guard at top of object validator', () => {
-    const schema = { type: 'object' as const, properties: { x: { type: 'string' as const } } }
-    const code = generateValidatorFunction(schema, 'Foo')
-
-    expect(code).toContain("typeof input !== 'object'")
-    expect(code).toContain('Array.isArray(input)')
-    expect(code).toContain('must be object')
-  })
-
-  it('generates an instanceof check for a required x-mjst Date property', () => {
-    const schema = {
-      type: 'object' as const,
-      properties: { createdAt: { 'x-mjst': { instanceOf: 'Date' } } },
-      required: ['createdAt'],
-    }
-    const code = generateValidatorFunction(schema, 'Event')
-
-    expect(code).toContain('"createdAt" in obj')
-    expect(code).toContain('!(obj["createdAt"] instanceof Date)')
-    expect(code).toContain('must be Date')
-  })
-
-  it('generates an instanceof check for an optional x-mjst Date property', () => {
-    const schema = {
-      type: 'object' as const,
-      properties: { createdAt: { 'x-mjst': { instanceOf: 'Date' } } },
-    }
-    const code = generateValidatorFunction(schema, 'Event')
-
-    expect(code).toContain('obj["createdAt"] !== undefined && !(obj["createdAt"] instanceof Date)')
-  })
-
-  it('generates an instanceof check for a top-level x-mjst Date schema', () => {
-    const code = generateValidatorFunction({ 'x-mjst': { instanceOf: 'Date' } }, 'When')
-
-    expect(code).toContain('!(input instanceof Date)')
-    expect(code).toContain('must be Date')
-  })
-
-  it('generates a typeof check for a required x-mjst bigint property', () => {
-    const schema = {
-      type: 'object' as const,
-      properties: { balance: { 'x-mjst': { primitive: 'bigint' } } },
-      required: ['balance'],
-    }
-    const code = generateValidatorFunction(schema, 'Account')
-
-    expect(code).toContain('typeof obj["balance"] !== "bigint"')
-    expect(code).toContain('must be bigint')
-  })
-
-  it('guards undefined for an optional x-mjst bigint property', () => {
-    const schema = {
-      type: 'object' as const,
-      properties: { balance: { 'x-mjst': { primitive: 'bigint' } } },
-    }
-    const code = generateValidatorFunction(schema, 'Account')
-
-    expect(code).toContain('obj["balance"] !== undefined && typeof obj["balance"] !== "bigint"')
-  })
-
-  it('generates a typeof check for a top-level x-mjst bigint schema', () => {
-    const code = generateValidatorFunction({ 'x-mjst': { primitive: 'bigint' } }, 'Big')
-
-    expect(code).toContain('typeof input !== "bigint"')
-    expect(code).toContain('must be bigint')
-  })
-})