@oomol-lab/open-flow 0.1.0-beta.73 → 0.1.0-beta.75

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`
+    }
+  }
+}

package/src/json-schema-subset/expression/calculator.ts

@@ -0,0 +1,442 @@
+import type { Combination } from './combination.ts'
+import type { ExpressionResult } from './result.ts'
+
+import { makeCombination } from './combination.ts'
+import {
+  ExpressionNone,
+  ExpressionSingleResult,
+  ExpressionEquals,
+  ExpressionContaining,
+  ExpressionContainedBy,
+  ExpressionRejection,
+  ExpressionIntersection,
+  ExpressionMaskList,
+} from './result.ts'
+
+export const CalculatorOperator = Object.freeze({
+  Save: 0,
+  OneOf: 1,
+  AllOf: 2,
+  AnyOf: 3,
+  Not: 4,
+  Swap: 5,
+})
+
+export type CalculatorOperator = (typeof CalculatorOperator)[keyof typeof CalculatorOperator]
+
+export function calculate(operator: CalculatorOperator, expressions: readonly ExpressionResult[]): ExpressionResult {
+  switch (operator) {
+    case CalculatorOperator.Save: {
+      return expressions[0]
+    }
+    case CalculatorOperator.OneOf: {
+      return calculateOneOf(expressions)
+    }
+    case CalculatorOperator.AllOf:
+    case CalculatorOperator.AnyOf: {
+      return calculateCombination(operator, expressions)
+    }
+    case CalculatorOperator.Not:
+    case CalculatorOperator.Swap: {
+      return calculateUnary(operator, expressions[0])
+    }
+  }
+}
+
+export function swap(expression: ExpressionResult): ExpressionResult {
+  return calculateUnary(CalculatorOperator.Swap, expression)
+}
+
+/**
+ * The oneOf operator is indivisible, so `a + b + c` must be evaluated as one expression.
+ * ![](../../doc/images/all_of_expression.png)
+ */
+function calculateOneOf(expressions: readonly ExpressionResult[]): ExpressionResult {
+  // A single remaining branch makes oneOf equivalent to that branch.
+  if (expressions.length === 1) {
+    return expressions[0]
+  }
+  const unionSet = calculateCombination(CalculatorOperator.AnyOf, expressions)
+  const intersectionList: ExpressionResult[] = []
+
+  for (let i = 0; i < expressions.length; ++i) {
+    for (let j = i + 1; j < expressions.length; ++j) {
+      const left = expressions[i]
+      const right = expressions[j]
+      const intersection = calculateCombination(CalculatorOperator.AllOf, [left, right])
+      intersectionList.push(intersection)
+    }
+  }
+  const banZone = calculateCombination(CalculatorOperator.AnyOf, intersectionList)
+  const enableZone = calculateUnary(CalculatorOperator.Not, banZone)
+
+  return calculateCombination(CalculatorOperator.AllOf, [unionSet, enableZone])
+}
+
+function calculateCombination(operator: CalculatorOperator, expressions: readonly ExpressionResult[]): ExpressionResult {
+  if (expressions.length < 0) {
+    throw new Error('invalid expressions: empty array')
+  }
+  let combination: Combination
+
+  switch (operator) {
+    case CalculatorOperator.AllOf: {
+      combination = makeCombination(calculateAllOf)
+      break
+    }
+    case CalculatorOperator.AnyOf: {
+      combination = makeCombination(calculateAnyOf)
+      break
+    }
+    default: {
+      throw new Error(`invalid operator ${operator}`)
+    }
+  }
+  for (const expression of expressions) {
+    combination.push(expression)
+  }
+  return combination.result
+}
+
+function calculateUnary(operator: CalculatorOperator, expression: ExpressionResult): ExpressionResult {
+  let calculator: (expression: ExpressionSingleResult) => ExpressionResult
+  let result: ExpressionResult = ExpressionNone
+
+  switch (operator) {
+    case CalculatorOperator.Not: {
+      calculator = calculateNot
+      break
+    }
+    case CalculatorOperator.Swap: {
+      calculator = calculateSwap
+      break
+    }
+    default: {
+      throw new Error(`invalid operator ${operator}`)
+    }
+  }
+  for (const [singleExpression, maskExpression] of ExpressionMaskList) {
+    if (maskExpression & expression) {
+      result |= calculator(singleExpression)
+    }
+  }
+  return result
+}
+
+function calculateAllOf(e1: ExpressionSingleResult, e2: ExpressionSingleResult): ExpressionResult {
+  let result: ExpressionResult = ExpressionNone
+  switch (e1) {
+    case ExpressionSingleResult.Equals: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionEquals
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionEquals
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionContainedBy
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionNone
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionContainedBy
+          break
+        }
+      }
+      break
+    }
+    case ExpressionSingleResult.Containing: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionEquals
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionEquals | ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionContainedBy
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionRejection
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionIntersection | ExpressionContainedBy
+          break
+        }
+      }
+      break
+    }
+    case ExpressionSingleResult.ContainedBy: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionContainedBy
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionContainedBy
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionContainedBy
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionNone
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionContainedBy
+          break
+        }
+      }
+      break
+    }
+    case ExpressionSingleResult.Rejection: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionNone
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionRejection
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionNone
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionRejection
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionRejection
+          break
+        }
+      }
+      break
+    }
+    case ExpressionSingleResult.Intersection: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionContainedBy
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionIntersection | ExpressionContainedBy
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionContainedBy
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionRejection
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionContainedBy | ExpressionRejection | ExpressionIntersection
+          break
+        }
+      }
+      break
+    }
+  }
+  return result
+}
+
+function calculateAnyOf(e1: ExpressionSingleResult, e2: ExpressionSingleResult): ExpressionResult {
+  let result: ExpressionResult = ExpressionNone
+  switch (e1) {
+    case ExpressionSingleResult.Equals: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionEquals
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionEquals
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionContaining
+          break
+        }
+      }
+      break
+    }
+    case ExpressionSingleResult.Containing: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionContaining
+          break
+        }
+      }
+      break
+    }
+    case ExpressionSingleResult.ContainedBy: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionEquals
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionEquals | ExpressionContainedBy
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionIntersection
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionContaining | ExpressionIntersection
+          break
+        }
+      }
+      break
+    }
+    case ExpressionSingleResult.Rejection: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionIntersection
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionRejection
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionIntersection
+          break
+        }
+      }
+      break
+    }
+    case ExpressionSingleResult.Intersection: {
+      switch (e2) {
+        case ExpressionSingleResult.Equals: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.Containing: {
+          result = ExpressionContaining
+          break
+        }
+        case ExpressionSingleResult.ContainedBy: {
+          result = ExpressionContaining | ExpressionIntersection
+          break
+        }
+        case ExpressionSingleResult.Rejection: {
+          result = ExpressionIntersection
+          break
+        }
+        case ExpressionSingleResult.Intersection: {
+          result = ExpressionContaining | ExpressionIntersection
+          break
+        }
+      }
+      break
+    }
+  }
+  return result
+}
+
+function calculateNot(expression: ExpressionSingleResult): ExpressionResult {
+  let result: ExpressionResult = ExpressionNone
+  switch (expression) {
+    case ExpressionSingleResult.Equals: {
+      result = ExpressionRejection
+      break
+    }
+    case ExpressionSingleResult.Containing: {
+      result = ExpressionRejection
+      break
+    }
+    case ExpressionSingleResult.ContainedBy: {
+      result = ExpressionIntersection
+      break
+    }
+    case ExpressionSingleResult.Rejection: {
+      result = ExpressionEquals | ExpressionContaining
+      break
+    }
+    case ExpressionSingleResult.Intersection: {
+      result = ExpressionContainedBy | ExpressionIntersection
+      break
+    }
+  }
+  return result
+}
+
+function calculateSwap(expression: ExpressionResult): ExpressionResult {
+  let result: ExpressionResult = ExpressionNone
+  switch (expression) {
+    case ExpressionSingleResult.Equals: {
+      result = ExpressionEquals
+      break
+    }
+    case ExpressionSingleResult.Containing: {
+      result = ExpressionContainedBy
+      break
+    }
+    case ExpressionSingleResult.ContainedBy: {
+      result = ExpressionContaining
+      break
+    }
+    case ExpressionSingleResult.Rejection: {
+      result = ExpressionRejection
+      break
+    }
+    case ExpressionSingleResult.Intersection: {
+      result = ExpressionIntersection
+      break
+    }
+  }
+  return result
+}