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

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

@@ -0,0 +1,230 @@
+import type { JSONSchema7Definition } from 'json-schema'
+import type { CompiledSchema, SchemaPath } from '../compiler/index.ts'
+import type { Calculator, Describer, ExpressionDescription, ExpressionResult } from '../expression/index.ts'
+import type { ExtendsContext } from '../extends/index.ts'
+import type { Schema } from '../types.ts'
+import type { DeepReadonly } from '../utils.ts'
+import type { Context } from './cache.ts'
+
+import { CompiledKind, getKind, getPath } from '../compiler/index.ts'
+import {
+  swap,
+  expression,
+  ExpressionKind,
+  ExpressionEquals,
+  ExpressionContaining,
+  ExpressionContainedBy,
+  ExpressionRejection,
+  hasContainedBy,
+  hasEquals,
+  hasContaining,
+  hasIntersection,
+  hasRejection,
+} from '../expression/index.ts'
+import { isDeepEquals } from '../utils.ts'
+import { calculateArray } from './array.ts'
+import { wrapEqualsCheckerWithCache, wrapSchemaCalculatorWithCache } from './cache.ts'
+import { calculateEnumAndEnum, calculateEnumAndSchema } from './enumAndConst.ts'
+import { schemaEqualsChecker } from './equals.ts'
+import { calculateNumeric } from './numeric/index.ts'
+import { calculateObject } from './object.ts'
+import { calculateString } from './string.ts'
+
+export type Options = {
+  readonly printWarnLog?: boolean
+}
+
+export interface CheckResult {
+  readonly errorPath?: SchemaPath | undefined
+  readonly expression: ExpressionResult
+}
+
+type WritableContext<E> = { -readonly [K in keyof Context<E>]?: Context<E>[K] }
+
+export function checkWithResult<E>(extendsContext: ExtendsContext, schema1: Schema<E>, schema2: Schema<E>): CheckResult {
+  const context: WritableContext<E> = {}
+  const errorPaths: SchemaPath[] = []
+  const calculate = wrapSchemaCalculatorWithCache(calculator(extendsContext, context as Context<E>))
+  const describe = describer<E>()
+  const equals = schemaEqualsChecker<E>(extendsContext)
+  context.isEquals = wrapEqualsCheckerWithCache(isDeepEquals)
+  context.calculate = expression({
+    describe,
+    equals,
+    calculate,
+    observeCalculation: (left, right, result, swapped) => {
+      const comparisonResult = swapped ? swap(result) : result
+      if (!isDecisiveMismatch(comparisonResult)) return
+      const errorPath = swapped ? findMismatchPath(right, left) : findMismatchPath(left, right)
+      if (errorPath) errorPaths.push(errorPath)
+    },
+  })
+  Object.freeze(context)
+  const comparisonExpression = context.calculate(schema1, schema2)
+  return { errorPath: errorPaths[0], expression: comparisonExpression }
+}
+
+const describer =
+  <E>(): Describer<Schema<E>> =>
+  (schema: Schema<E>) => {
+    let description: ExpressionDescription<Schema<E>>
+    switch (getKind(schema)) {
+      case CompiledKind.Not: {
+        description = {
+          kind: ExpressionKind.Not,
+          expression: (schema as CompiledSchema<E>).not as Schema<E>,
+        }
+        break
+      }
+      case CompiledKind.Combination: {
+        if ('allOf' in schema) {
+          description = {
+            kind: ExpressionKind.AllOf,
+            expressions: rejectInSchemaList(schema.allOf, CompiledKind.Any),
+          }
+        } else if ('anyOf' in schema) {
+          description = {
+            kind: ExpressionKind.AnyOf,
+            expressions: rejectInSchemaList(schema.anyOf, CompiledKind.Never),
+          }
+        } else if ('oneOf' in schema) {
+          description = {
+            kind: ExpressionKind.OneOf,
+            expressions: rejectInSchemaList(schema.oneOf, CompiledKind.Never),
+          }
+        } else {
+          throw new Error(`invalid combination JSON Schema: ${JSON.stringify(schema)}`)
+        }
+        break
+      }
+      default: {
+        description = { kind: ExpressionKind.Leaf }
+        break
+      }
+    }
+    return description
+  }
+
+const calculator =
+  <E>(extendsContext: ExtendsContext, context: Context<E>): Calculator<Schema<E>> =>
+  (schema1, schema2) => {
+    const kind1 = getKind(schema1)
+    const kind2 = getKind(schema2)
+
+    if (kind1 === CompiledKind.Extends || kind2 === CompiledKind.Extends) {
+      return extendsContext.calculate(schema1, schema2)
+    }
+    switch (kind1) {
+      case CompiledKind.Any: {
+        return kind2 === CompiledKind.Any ? ExpressionEquals : ExpressionContaining
+      }
+      case CompiledKind.Never: {
+        return kind2 === CompiledKind.Never ? ExpressionEquals : ExpressionContainedBy
+      }
+    }
+    switch (kind2) {
+      case CompiledKind.Any: {
+        return ExpressionContainedBy
+      }
+      case CompiledKind.Never: {
+        return ExpressionContaining
+      }
+    }
+    if (kind1 === CompiledKind.EnumOrConst && kind2 === CompiledKind.EnumOrConst) {
+      return calculateEnumAndEnum(context, schema1 as CompiledSchema<E>, schema2 as CompiledSchema<E>)
+    }
+    if (kind1 === CompiledKind.EnumOrConst) {
+      return calculateEnumAndSchema(schema1 as CompiledSchema<E>, schema2 as CompiledSchema<E>)
+    }
+    if (kind2 === CompiledKind.EnumOrConst) {
+      return swap(calculateEnumAndSchema(schema2 as CompiledSchema<E>, schema1 as CompiledSchema<E>))
+    }
+    if (kind1 !== kind2) {
+      return ExpressionRejection
+    }
+    switch (kind1) {
+      case CompiledKind.Null: {
+        return ExpressionEquals
+      }
+      case CompiledKind.Numeric: {
+        return calculateNumeric(schema1 as CompiledSchema<E>, schema2 as CompiledSchema<E>)
+      }
+      case CompiledKind.String: {
+        return calculateString(schema1 as CompiledSchema<E>, schema2 as CompiledSchema<E>)
+      }
+      case CompiledKind.Boolean: {
+        return ExpressionEquals
+      }
+      case CompiledKind.Object: {
+        return calculateObject(context, schema1 as CompiledSchema<E>, schema2 as CompiledSchema<E>)
+      }
+      case CompiledKind.Array: {
+        return calculateArray(context, schema1 as CompiledSchema<E>, schema2 as CompiledSchema<E>)
+      }
+      default: {
+        throw new Error(`invalid kind ${kind1}`)
+      }
+    }
+  }
+
+function rejectInSchemaList<E>(schemaList: DeepReadonly<JSONSchema7Definition[]> | undefined, kind: CompiledKind): CompiledSchema<E>[] {
+  return (schemaList as CompiledSchema<E>[]).filter((e) => getKind(e) !== kind)
+}
+
+function isDecisiveMismatch(result: ExpressionResult): boolean {
+  return !hasEquals(result) && !hasContainedBy(result) && (hasContaining(result) || hasIntersection(result) || hasRejection(result))
+}
+
+function findMismatchPath<E>(source: Schema<E>, target: Schema<E>): SchemaPath | undefined {
+  const targetPath = getPath(target)
+  if (!targetPath) return undefined
+  const sourceKind = getKind(source)
+  const targetKind = getKind(target)
+  if (sourceKind !== targetKind) return [...targetPath, 'type']
+
+  const sourceSchema = source as CompiledSchema<E>
+  const targetSchema = target as CompiledSchema<E>
+  switch (targetKind) {
+    case CompiledKind.String: {
+      if ((sourceSchema.minLength ?? 0) < (targetSchema.minLength ?? 0)) return [...targetPath, 'minLength']
+      if ((sourceSchema.maxLength ?? Number.POSITIVE_INFINITY) > (targetSchema.maxLength ?? Number.POSITIVE_INFINITY)) return [...targetPath, 'maxLength']
+      if (sourceSchema.pattern !== targetSchema.pattern && targetSchema.pattern) return [...targetPath, 'pattern']
+      if (sourceSchema.format !== targetSchema.format && targetSchema.format) return [...targetPath, 'format']
+      break
+    }
+    case CompiledKind.Numeric: {
+      if (
+        (sourceSchema.minimum ?? sourceSchema.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) <
+        (targetSchema.minimum ?? targetSchema.exclusiveMinimum ?? Number.NEGATIVE_INFINITY)
+      ) {
+        return [...targetPath, targetSchema.exclusiveMinimum == null ? 'minimum' : 'exclusiveMinimum']
+      }
+      if (
+        (sourceSchema.maximum ?? sourceSchema.exclusiveMaximum ?? Number.POSITIVE_INFINITY) >
+        (targetSchema.maximum ?? targetSchema.exclusiveMaximum ?? Number.POSITIVE_INFINITY)
+      ) {
+        return [...targetPath, targetSchema.exclusiveMaximum == null ? 'maximum' : 'exclusiveMaximum']
+      }
+      if (sourceSchema.multipleOf !== targetSchema.multipleOf && targetSchema.multipleOf != null) return [...targetPath, 'multipleOf']
+      break
+    }
+    case CompiledKind.Array: {
+      if ((sourceSchema.minItems ?? 0) < (targetSchema.minItems ?? 0)) return [...targetPath, 'minItems']
+      if ((sourceSchema.maxItems ?? Number.POSITIVE_INFINITY) > (targetSchema.maxItems ?? Number.POSITIVE_INFINITY)) return [...targetPath, 'maxItems']
+      if (!sourceSchema.uniqueItems && targetSchema.uniqueItems) return [...targetPath, 'uniqueItems']
+      break
+    }
+    case CompiledKind.Object: {
+      const sourceRequired = new Set(sourceSchema.required ?? [])
+      if ((targetSchema.required ?? []).some((key) => !sourceRequired.has(key))) return [...targetPath, 'required']
+      if ((sourceSchema.minProperties ?? 0) < (targetSchema.minProperties ?? 0)) return [...targetPath, 'minProperties']
+      if ((sourceSchema.maxProperties ?? Number.POSITIVE_INFINITY) > (targetSchema.maxProperties ?? Number.POSITIVE_INFINITY))
+        return [...targetPath, 'maxProperties']
+      break
+    }
+    case CompiledKind.EnumOrConst: {
+      return [...targetPath, targetSchema.const === undefined ? 'enum' : 'const']
+    }
+  }
+  return targetPath
+}

package/src/json-schema-subset/checker/enumAndConst.ts

@@ -0,0 +1,113 @@
+import type { CompiledSchema, CompiledValue } from '../compiler/index.ts'
+import type { ExpressionResult } from '../expression/index.ts'
+import type { Context } from './cache.ts'
+
+import { getKind, CompiledKind } from '../compiler/index.ts'
+import {
+  ExpressionAny,
+  ExpressionEquals,
+  ExpressionContaining,
+  ExpressionContainedBy,
+  ExpressionIntersection,
+  ExpressionRejection,
+} from '../expression/index.ts'
+import { valid, ValidResult } from './validator.ts'
+
+export function calculateEnumAndEnum<E>(context: Context<E>, schema1: CompiledSchema<E>, schema2: CompiledSchema<E>): ExpressionResult {
+  const enumList1 = normalizeEnumList(schema1)
+  const enumList2 = normalizeEnumList(schema2)
+
+  let foundExtra1 = false
+  let foundExtra2 = false
+  let foundIntersection = false
+
+  for (const enum1 of enumList1) {
+    if (hasEqualsEnum(context, enumList2, enum1)) {
+      foundIntersection = true
+    } else {
+      foundExtra1 = true
+    }
+    if (foundExtra1 && foundIntersection) {
+      break
+    }
+  }
+  for (const enum2 of enumList2) {
+    if (hasEqualsEnum(context, enumList1, enum2)) {
+      foundIntersection = true
+    } else {
+      foundExtra2 = true
+    }
+    if (foundExtra2 && foundIntersection) {
+      break
+    }
+  }
+  if (!foundIntersection) {
+    return ExpressionRejection
+  }
+  if (foundExtra1 && foundExtra2) {
+    return ExpressionIntersection
+  }
+  if (foundExtra1) {
+    return ExpressionContaining
+  }
+  if (foundExtra2) {
+    return ExpressionContainedBy
+  }
+  return ExpressionEquals
+}
+
+export function calculateEnumAndSchema<E>(enumSchema: CompiledSchema<E>, schema: CompiledSchema<E>): ExpressionResult {
+  let hasValid = false
+  let hasInvalid = false
+
+  for (const enumValue of normalizeEnumList(enumSchema)) {
+    switch (valid(schema, enumValue)) {
+      case ValidResult.Valid: {
+        hasValid = true
+        break
+      }
+      case ValidResult.Invalid: {
+        hasInvalid = true
+        break
+      }
+      case ValidResult.Unknown: {
+        return ExpressionAny
+      }
+    }
+    if (hasValid && hasInvalid) {
+      break
+    }
+  }
+  if (hasValid && hasInvalid) {
+    return ExpressionIntersection
+  }
+  if (hasValid) {
+    return ExpressionEquals | ExpressionContainedBy
+  }
+  if (hasInvalid) {
+    return ExpressionRejection
+  }
+  if (getKind(schema) === CompiledKind.Never) {
+    return ExpressionEquals
+  }
+  return ExpressionContainedBy
+}
+
+function normalizeEnumList<E>({ const: constValue, enum: enumList }: CompiledSchema<E>): CompiledValue[] {
+  if (constValue !== undefined) {
+    return [constValue as CompiledValue]
+  }
+  if (enumList) {
+    return enumList as CompiledValue[]
+  }
+  throw new Error('invalid branch')
+}
+
+function hasEqualsEnum<E>({ isEquals }: Context<E>, enumList: CompiledValue[], checkedEnum: CompiledValue): boolean {
+  for (const searchedEnum of enumList) {
+    if (isEquals(searchedEnum, checkedEnum)) {
+      return true
+    }
+  }
+  return false
+}

package/src/json-schema-subset/checker/equals.ts

@@ -0,0 +1,93 @@
+import type { CompiledSchema } from '../compiler/index.ts'
+import type { ExtendsContext } from '../extends/index.ts'
+import type { Schema } from '../types.ts'
+
+import { getId, isCompiledSchema } from '../compiler/index.ts'
+
+export function schemaEqualsChecker<E>(extendsContext: ExtendsContext): (schema1: Schema<E>, schema2: Schema<E>) => boolean {
+  function isSchemaEquals(schema1: Schema<E>, schema2: Schema<E>): boolean {
+    const isExtends1 = extendsContext.isExtendsSchema(schema1)
+    const isExtends2 = extendsContext.isExtendsSchema(schema2)
+
+    if (isExtends1 || isExtends2) {
+      return extendsContext.equals(schema1, schema2)
+    } else {
+      return isCompiledSchemaEquals(schema1, schema2)
+    }
+  }
+  const equalsMap = new Map<string, boolean>()
+
+  function isCompiledSchemaEquals(schema1: CompiledSchema<E>, schema2: CompiledSchema<E>): boolean {
+    const id1 = getId(schema1)
+    const id2 = getId(schema2)
+
+    if (id1 === id2) {
+      return true
+    }
+    const key = `${id1}/${id2}`
+    let isEquals = equalsMap.get(key)
+
+    if (isEquals === undefined) {
+      isEquals = isObjectLikeEquals(schema1, schema2)
+      equalsMap.set(key, isEquals)
+    }
+    return isEquals
+  }
+
+  function isObjectLikeEquals(object1: object, object2: object): boolean {
+    if (Array.isArray(object1)) {
+      if (!Array.isArray(object2)) {
+        return false
+      }
+      if (object1.length !== object2.length) {
+        return false
+      }
+      for (const [i, value1Element] of object1.entries()) {
+        if (!isValueEquals(value1Element, object2[i])) {
+          return false
+        }
+      }
+    } else {
+      if (Array.isArray(object2)) {
+        return false
+      }
+      for (const key in object1) {
+        if (!(key in object2)) {
+          return false
+        }
+        const value1: unknown = Reflect.get(object1, key)
+        const value2: unknown = Reflect.get(object2, key)
+        if (!isValueEquals(value1, value2)) {
+          return false
+        }
+      }
+      for (const key in object2) {
+        if (!(key in object1)) {
+          return false
+        }
+      }
+    }
+    return true
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  function isValueEquals(value1: any, value2: any): boolean {
+    if (value1 === value2) {
+      return true
+    }
+    if (value1 === null || value2 === null) {
+      return false
+    }
+    if (typeof value1 !== 'object') {
+      return false
+    }
+    if (typeof value1 !== typeof value2) {
+      return false
+    }
+    if (isCompiledSchema<E>(value1) && isCompiledSchema<E>(value2)) {
+      return isCompiledSchemaEquals(value1, value2)
+    }
+    return isObjectLikeEquals(value1, value2)
+  }
+  return isSchemaEquals
+}

package/src/json-schema-subset/checker/numeric/checker.ts

@@ -0,0 +1,50 @@
+import type { CompiledSchema } from '../../compiler/index.ts'
+import type { ExpressionResult } from '../../expression/index.ts'
+
+import { swap, ExpressionAny } from '../../expression/index.ts'
+import { calculateFloat, calculateFloatAndInteger } from './float.ts'
+import { calculateInteger } from './integer.ts'
+
+export function calculateNumeric<E>(schema1: CompiledSchema<E>, schema2: CompiledSchema<E>): ExpressionResult {
+  if (isUndefinedNumber(schema1) || isUndefinedNumber(schema2)) {
+    return ExpressionAny
+  }
+  const isFloat1 = isFloat(schema1)
+  const isFloat2 = isFloat(schema2)
+
+  if (isFloat1 && isFloat2) {
+    return calculateFloat(schema1, schema2)
+  } else if (isFloat1) {
+    return calculateFloatAndInteger(schema1, schema2)
+  } else if (isFloat2) {
+    return swap(calculateFloatAndInteger(schema2, schema1))
+  } else {
+    return calculateInteger(schema1, schema2)
+  }
+}
+
+function isUndefinedNumber<E>(schema: CompiledSchema<E>): boolean {
+  const { multipleOf } = schema
+  if (multipleOf === undefined) {
+    return false
+  }
+  if (!Number.isInteger(multipleOf)) {
+    return true
+  }
+  if (multipleOf < 0) {
+    return true
+  }
+  return false
+}
+
+function isFloat<E>(schema: CompiledSchema<E>): boolean {
+  const { multipleOf } = schema
+
+  if (multipleOf !== undefined && Number.isInteger(multipleOf)) {
+    return false
+  }
+  if (schema.type === 'integer') {
+    return false
+  }
+  return true
+}

package/src/json-schema-subset/checker/numeric/float.ts

@@ -0,0 +1,121 @@
+import type { CompiledSchema } from '../../compiler/index.ts'
+import type { ExpressionResult } from '../../expression/index.ts'
+import type { Point, Range, SplitterSide } from '../tools/index.ts'
+
+import { ExpressionEquals, ExpressionContaining, ExpressionContainedBy, ExpressionIntersection, ExpressionRejection } from '../../expression/index.ts'
+import { splitRange } from '../tools/index.ts'
+import { isPointRange, cutRange, normalizeInteger } from './integerNormalizer.ts'
+
+export function calculateFloat<E>(schema1: CompiledSchema<E>, schema2: CompiledSchema<E>): ExpressionResult {
+  const range1 = pickRange(schema1)
+  const range2 = pickRange(schema2)
+  const { left, right, center } = splitRange(range1, range2)
+
+  if (!center) {
+    return ExpressionRejection
+  }
+  let extraLeft = false
+  let extraRight = false
+
+  if (left) {
+    if (left.fromLeft) {
+      extraLeft = true
+    } else {
+      extraRight = true
+    }
+  }
+  if (right) {
+    if (right.fromLeft) {
+      extraLeft = true
+    } else {
+      extraRight = true
+    }
+  }
+  if (extraLeft && extraRight) {
+    return ExpressionIntersection
+  }
+  if (extraLeft) {
+    return ExpressionContaining
+  }
+  if (extraRight) {
+    return ExpressionContainedBy
+  }
+  return ExpressionEquals
+}
+
+export function calculateFloatAndInteger<E>(schema1: CompiledSchema<E>, schema2: CompiledSchema<E>): ExpressionResult {
+  const floatRange = pickRange(schema1)
+  const integer = normalizeInteger(schema2)
+
+  if (!integer) {
+    return ExpressionContaining
+  }
+  const result = splitRange(floatRange, integer.range)
+  const intCenter = cutRange(result.center, integer.multipleOf)
+  const leftIntRange = unwrapAndCutRange(result.left, integer.multipleOf)
+  const rightIntRange = unwrapAndCutRange(result.right, integer.multipleOf)
+
+  if (!result.center) {
+    return ExpressionRejection
+  }
+  let extraFloat = false
+  let extraInteger = false
+
+  if (result.left?.fromLeft) {
+    extraFloat = true
+  }
+  if (result.right?.fromLeft) {
+    extraFloat = true
+  }
+  if (!intCenter || !isPointRange(result.center)) {
+    extraFloat = true
+  }
+  if (leftIntRange) {
+    extraInteger = true
+  }
+  if (rightIntRange) {
+    extraInteger = true
+  }
+  if (extraFloat && extraInteger) {
+    return ExpressionIntersection
+  }
+  if (extraFloat) {
+    return ExpressionContaining
+  }
+  if (extraInteger) {
+    return ExpressionContainedBy
+  }
+  return ExpressionEquals
+}
+
+export function pickRange<E>(schema: CompiledSchema<E>): Range {
+  let point1: Point
+  let point2: Point
+
+  if (schema.exclusiveMinimum !== undefined) {
+    point1 = { num: schema.exclusiveMinimum, exclusive: true }
+  } else if (schema.minimum !== undefined) {
+    point1 = { num: schema.minimum, exclusive: false }
+  } else {
+    point1 = { num: Number.NEGATIVE_INFINITY, exclusive: true }
+  }
+  if (schema.exclusiveMaximum !== undefined) {
+    point2 = { num: schema.exclusiveMaximum, exclusive: true }
+  } else if (schema.maximum !== undefined) {
+    point2 = { num: schema.maximum, exclusive: false }
+  } else {
+    point2 = { num: Number.POSITIVE_INFINITY, exclusive: true }
+  }
+  return [point1, point2]
+}
+
+function unwrapAndCutRange(side: SplitterSide | undefined, multipleOf: number): Range | undefined {
+  if (!side) {
+    return undefined
+  }
+  if (side.fromLeft) {
+    // left is always float in this file
+    return undefined
+  }
+  return cutRange(side.range, multipleOf)
+}

package/src/json-schema-subset/checker/numeric/index.ts

@@ -0,0 +1 @@
+export { calculateNumeric } from './checker.ts'