@oomol-lab/open-flow 0.1.0-beta.72 → 0.1.0-beta.74

package/src/json-schema-subset/compiler/primitive.ts

@@ -0,0 +1,144 @@
+import type { JSONSchema7, JSONSchema7TypeName } from 'json-schema'
+import type { Context } from './common.ts'
+import type { InputSchema } from './compiler.ts'
+import type { CompiledSchema } from './wrapper.ts'
+
+import { pick } from '../utils.ts'
+import { recordError, isJSONSchemaKey, recordWarn } from './common.ts'
+import { CompiledKind, wrapCompiledSchema } from './wrapper.ts'
+
+type NumericKeys = 'type' | 'multipleOf' | 'maximum' | 'exclusiveMaximum' | 'minimum' | 'exclusiveMinimum'
+type StringKeys = 'type' | 'format' | 'maxLength' | 'minLength' | 'pattern'
+
+const NUMERIC_KEYS = new Set<NumericKeys>(['type', 'multipleOf', 'maximum', 'exclusiveMaximum', 'minimum', 'exclusiveMinimum'])
+const STRING_KEYS = new Set<StringKeys>(['type', 'format', 'maxLength', 'minLength', 'pattern'])
+
+export type PrimitiveInputSchema = InputSchema & {
+  readonly type: Exclude<JSONSchema7TypeName, 'object' | 'array'>
+}
+
+export function compilePrimitiveSchema<E>(context: Context<E>, schema: PrimitiveInputSchema): CompiledSchema<E> | null {
+  const { type } = schema
+  switch (type) {
+    case 'number':
+    case 'integer': {
+      return compileNumericSchema(context, schema)
+    }
+    case 'string': {
+      return compileStringSchema(context, schema)
+    }
+    case 'boolean':
+    case 'null': {
+      const rejectKeys = Object.keys(schema).filter((k) => isJSONSchemaKey(k) && k !== 'type')
+      if (rejectKeys.length > 0) {
+        recordWarn(context, `key "type" will exclude other keys: ${rejectKeys.toSorted().join(', ')}`)
+      }
+      const kind = type === 'null' ? CompiledKind.Null : CompiledKind.Boolean
+      const compiledSchema = { type }
+      return wrapCompiledSchema(kind, compiledSchema, context.delegate, context.path)
+    }
+    default: {
+      recordError(context, `invalid type ${JSON.stringify(type)}`)
+      return null
+    }
+  }
+}
+
+function compileNumericSchema<E>(context: Context<E>, schema: PrimitiveInputSchema): CompiledSchema<E> | null {
+  const rejectKeys = Object.keys(schema).filter((k) => !NUMERIC_KEYS.has(k as NumericKeys) && isJSONSchemaKey(k))
+  if (rejectKeys.length > 0) {
+    recordWarn(context, `type=${JSON.stringify(schema.type)} will exclude other keys: ${rejectKeys.toSorted().join(', ')}`)
+  }
+  const compiledSchema = pick(schema, NUMERIC_KEYS)
+
+  for (const key of NUMERIC_KEYS) {
+    const value = compiledSchema[key]
+    if (key !== 'type' && value !== undefined && Number.isNaN(value)) {
+      recordWarn(context, 'found NaN', key)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      delete (compiledSchema as any)[key]
+    }
+  }
+  const { maximum, exclusiveMaximum, minimum, exclusiveMinimum } = compiledSchema
+
+  if (maximum !== undefined && exclusiveMaximum !== undefined) {
+    if (maximum === exclusiveMaximum) {
+      delete compiledSchema.maximum
+    } else if (maximum < exclusiveMaximum) {
+      delete compiledSchema.exclusiveMaximum
+    } else if (maximum > exclusiveMaximum) {
+      delete compiledSchema.maximum
+    }
+  }
+  if (minimum !== undefined && exclusiveMinimum !== undefined) {
+    if (minimum === exclusiveMinimum) {
+      delete compiledSchema.minimum
+    } else if (minimum < exclusiveMinimum) {
+      delete compiledSchema.exclusiveMinimum
+    } else if (minimum > exclusiveMinimum) {
+      delete compiledSchema.minimum
+    }
+  }
+  const { multipleOf } = compiledSchema
+
+  if (multipleOf === 0) {
+    delete compiledSchema.multipleOf
+    compiledSchema.type = 'number'
+    recordWarn(context, 'cannot be 0', 'multipleOf')
+  }
+  let kind: CompiledKind = CompiledKind.Numeric
+  if (!isNumericPossibleInvalid(compiledSchema)) {
+    kind = CompiledKind.Never
+  }
+  return wrapCompiledSchema(kind, compiledSchema, context.delegate, context.path)
+}
+
+function isNumericPossibleInvalid(compiledSchema: JSONSchema7): boolean {
+  const { maximum, exclusiveMaximum, minimum, exclusiveMinimum } = compiledSchema
+
+  if (maximum !== undefined && minimum !== undefined) {
+    return maximum >= minimum
+  } else if (exclusiveMaximum !== undefined && minimum !== undefined) {
+    return exclusiveMaximum > minimum
+  } else if (maximum !== undefined && exclusiveMinimum !== undefined) {
+    return maximum > exclusiveMinimum
+  } else if (exclusiveMaximum !== undefined && exclusiveMinimum !== undefined) {
+    return exclusiveMaximum > exclusiveMinimum
+  } else {
+    return true
+  }
+}
+
+function compileStringSchema<E>(context: Context<E>, schema: PrimitiveInputSchema): CompiledSchema<E> | null {
+  const rejectKeys = Object.keys(schema).filter((k) => !STRING_KEYS.has(k as StringKeys) && isJSONSchemaKey(k))
+  if (rejectKeys.length > 0) {
+    recordWarn(context, `type="string" will exclude other keys: ${rejectKeys.toSorted().join(', ')}`)
+  }
+  const compiledSchema = pick(schema, STRING_KEYS)
+
+  cleanInvalidLength(context, compiledSchema, 'maxLength')
+  cleanInvalidLength(context, compiledSchema, 'minLength')
+
+  const max = compiledSchema.maxLength
+  const min = compiledSchema.minLength
+  let kind: CompiledKind = CompiledKind.String
+
+  if (max !== undefined) {
+    if (max < 0) {
+      kind = CompiledKind.Never
+    } else if (max !== undefined && min !== undefined && max < min) {
+      kind = CompiledKind.Never
+    }
+  }
+  return wrapCompiledSchema(kind, compiledSchema, context.delegate, context.path)
+}
+
+function cleanInvalidLength<E>(context: Context<E>, compiledSchema: JSONSchema7, key: 'maxLength' | 'minLength'): void {
+  const length = compiledSchema[key]
+  if (length !== undefined) {
+    if (Number.isNaN(length)) {
+      recordWarn(context, 'found NaN', key)
+      delete compiledSchema[key]
+    }
+  }
+}

package/src/json-schema-subset/compiler/utils.ts

@@ -0,0 +1,24 @@
+export function cleanEmptyValues<T extends object>(origin: T): Partial<T> {
+  for (const key in origin) {
+    const value = origin[key]
+    if (value === undefined) {
+      delete origin[key]
+    } else if (value && typeof value === 'object') {
+      if (Array.isArray(value)) {
+        if (value.length === 0) {
+          delete origin[key]
+        }
+      } else if (isEmptyObject(value)) {
+        delete origin[key]
+      }
+    }
+  }
+  return origin
+}
+
+function isEmptyObject(object: object): boolean {
+  for (const _ in object) {
+    return false
+  }
+  return true
+}

package/src/json-schema-subset/compiler/wrapper.ts

@@ -0,0 +1,192 @@
+import type { JSONSchema7 } from 'json-schema'
+import type { ExtendsSchema } from '../extends/index.ts'
+import type { Schema } from '../types.ts'
+import type { JSONDelegate } from '../types.ts'
+import type { DeepReadonly } from '../utils.ts'
+
+import { createId, deepFreeze } from '../utils.ts'
+
+const symbolID = Symbol('compiledId')
+const symbolKind = Symbol('compiledKind')
+const symbolPath = Symbol('compiledPath')
+const symbolValidatorLoader = Symbol('validatorLoader')
+
+export type SchemaPath = readonly (string | number)[]
+
+export const CompiledKind = Object.freeze({
+  Extends: 0,
+  Never: 1,
+  Any: 2,
+  Null: 3,
+  String: 4,
+  Numeric: 5,
+  Boolean: 6,
+  Object: 7,
+  Array: 8,
+  Not: 9,
+  Combination: 10,
+  EnumOrConst: 11,
+})
+
+export type CompiledKind = (typeof CompiledKind)[keyof typeof CompiledKind]
+
+export type CompiledValue = null | number | string | boolean | CompiledObject
+export type CompiledObject = (CompiledValue[] | { [key: string]: CompiledValue }) & {
+  readonly [symbolID]: number
+}
+
+type ValidatorLoader<E> = () => (value: unknown) => boolean | readonly E[]
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const ANY: DeepReadonly<CompiledSchema<any>> = deepFreeze(toCompiledSchema(CompiledKind.Any, createId(), {}, () => () => true))
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const NEVER: DeepReadonly<CompiledSchema<any>> = deepFreeze(
+  toCompiledSchema(CompiledKind.Never, createId(), { type: 'string', maxLength: 0, minLength: 1 }, () => () => false),
+)
+
+export interface CompiledSchema<E> extends JSONSchema7 {
+  readonly [symbolKind]: CompiledKind
+  readonly [symbolID]: number
+  readonly [symbolPath]: SchemaPath
+  readonly [symbolValidatorLoader]?: ValidatorLoader<E>
+  readonly isValid?: (value: unknown) => boolean | readonly E[]
+}
+
+export function isCompiledObject(value: unknown): value is DeepReadonly<CompiledObject> {
+  if (value === null || typeof value !== 'object') {
+    return false
+  }
+  return symbolID in value
+}
+
+export function isCompiledSchema<E>(object: unknown): object is DeepReadonly<CompiledSchema<E>> {
+  if (object === null || typeof object !== 'object') {
+    return false
+  }
+  return symbolID in object && symbolKind in object
+}
+
+export function getKind<E>(schema: Schema<E>): CompiledKind {
+  if (isCompiledSchema(schema)) {
+    return schema[symbolKind]
+  } else {
+    return CompiledKind.Extends
+  }
+}
+
+export function getId<E>(schema: ExtendsSchema | DeepReadonly<CompiledSchema<E>> | DeepReadonly<CompiledObject>): number {
+  if (isCompiledSchema(schema) || isCompiledObject(schema)) {
+    return schema[symbolID]
+  } else {
+    return (schema as ExtendsSchema).id
+  }
+}
+
+export function getPath<E>(schema: Schema<E>): SchemaPath | undefined {
+  return isCompiledSchema(schema) ? schema[symbolPath] : undefined
+}
+
+export function assertCompiledValue<V>(value: V): asserts value is V & CompiledValue {
+  let failure = false
+  switch (typeof value) {
+    case 'number':
+    case 'string':
+    case 'boolean': {
+      break
+    }
+    case 'object': {
+      failure = !isCompiledObject(value)
+      break
+    }
+    default: {
+      failure = true
+      break
+    }
+  }
+  if (failure) {
+    throw new Error('assert a CompiledValue but fail')
+  }
+}
+
+export function wrapCompiledValue(value: unknown): CompiledValue {
+  if (value === null || typeof value !== 'object') {
+    return value as CompiledValue
+  }
+  Object.defineProperty(value, symbolID, {
+    value: createId(),
+    configurable: false,
+    writable: false,
+    enumerable: false,
+  })
+  return value as CompiledValue
+}
+
+export function wrapCompiledSchema<E>(kind: CompiledKind, schema: JSONSchema7, delegate?: JSONDelegate<E>, path: SchemaPath = []): CompiledSchema<E> {
+  return toCompiledSchema(
+    kind,
+    createId(),
+    schema,
+    delegate &&
+      (() => {
+        return delegate.compile(schema)
+      }),
+    path,
+  )
+}
+
+export function toNever<T extends CompiledSchema<E>, E>(schema: T): T {
+  return toCompiledSchema(CompiledKind.Never, createId(), { ...schema }, schema[symbolValidatorLoader], schema[symbolPath]) as T
+}
+
+function toCompiledSchema<E>(
+  kind: CompiledKind,
+  id: number,
+  schema: JSONSchema7,
+  validatorLoader?: ValidatorLoader<E>,
+  path: SchemaPath = [],
+): CompiledSchema<E> {
+  let validator: ReturnType<ValidatorLoader<E>> | null = null
+
+  Object.defineProperties(schema, {
+    [symbolKind]: {
+      value: kind,
+      configurable: false,
+      writable: false,
+      enumerable: false,
+    },
+    [symbolID]: {
+      value: id,
+      configurable: false,
+      writable: false,
+      enumerable: false,
+    },
+    [symbolPath]: {
+      value: path,
+      configurable: false,
+      writable: false,
+      enumerable: false,
+    },
+    [symbolValidatorLoader]: {
+      value: validatorLoader,
+      configurable: false,
+      writable: false,
+      enumerable: false,
+    },
+    isValid: {
+      configurable: false,
+      enumerable: false,
+      get: (): ((value: unknown) => boolean | readonly E[]) | undefined => {
+        if (validatorLoader) {
+          if (!validator) {
+            validator = validatorLoader()
+          }
+          return validator
+        } else {
+          return undefined
+        }
+      },
+    },
+  })
+  return schema as CompiledSchema<E>
+}

package/src/json-schema-subset/error.ts

@@ -0,0 +1,55 @@
+export class SchemaError<E = unknown> extends Error {
+  public readonly items: readonly SchemaErrorItem<E>[]
+
+  public constructor(items: readonly SchemaErrorItem<E>[] = []) {
+    super(createSchemaErrorMessage(items))
+    this.name = 'SchemaError'
+    this.items = items
+  }
+}
+
+export type SchemaErrorItem<E = unknown> = CompiledSchemaErrorItem | ExternalSchemaErrorItem<E>
+
+export type CompiledSchemaErrorItem = {
+  readonly kind: typeof SchemaErrorItemKind.Compiled
+  readonly path: (number | string)[]
+  readonly message: string
+}
+
+export type ExternalSchemaErrorItem<E = unknown> = {
+  readonly kind: typeof SchemaErrorItemKind.External
+  readonly error: E
+}
+
+export const SchemaErrorItemKind = Object.freeze({
+  Compiled: 0,
+  External: 1,
+})
+
+export type SchemaErrorItemKind = (typeof SchemaErrorItemKind)[keyof typeof SchemaErrorItemKind]
+
+export function stringifySchemaError<E = unknown>(errorItem: SchemaErrorItem<E>): string {
+  switch (errorItem.kind) {
+    case SchemaErrorItemKind.Compiled: {
+      const { message, path } = errorItem
+      return `${message} (at ${path.length > 0 ? path.join('.') : '$root'})`
+    }
+    case SchemaErrorItemKind.External: {
+      return String(errorItem.error)
+    }
+  }
+}
+
+function createSchemaErrorMessage(items: readonly SchemaErrorItem[]): string {
+  switch (items.length) {
+    case 0: {
+      return 'without any items'
+    }
+    case 1: {
+      return stringifySchemaError(items[0])
+    }
+    default: {
+      return `${stringifySchemaError(items[0])} ... omit the rest ${items.length - 1} items`
+    }
+  }
+}