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

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

@@ -0,0 +1,210 @@
+export type Range = readonly [Point, Point]
+export type Point = {
+  readonly num: number
+  readonly exclusive: boolean
+}
+
+export type Splitter = {
+  readonly left?: SplitterSide
+  readonly right?: SplitterSide
+  readonly center?: Range
+}
+
+export type SplitterSide = {
+  readonly fromLeft: boolean
+  readonly range: Range
+}
+
+export function splitRange(range1: Range, range2: Range): Splitter {
+  const [min1] = range1
+  const [min2] = range2
+
+  if (min1.num < min2.num) {
+    return splitRangeLessBranch(range1, range2)
+  } else if (min1.num > min2.num) {
+    return splitRangeGreaterBranch(range1, range2)
+  } else {
+    return splitRangeEqualsBranch(range1, range2)
+  }
+}
+
+function splitRangeLessBranch(range1: Range, range2: Range): Splitter {
+  const [min1, max1] = range1
+  const [min2, max2] = range2
+
+  if (max1.num <= min2.num) {
+    const exclusive1 = max1.exclusive
+    const exclusive2 = min2.exclusive
+    if (max1.num < min2.num || exclusive1 || exclusive2) {
+      return {
+        left: { fromLeft: true, range: range1 },
+        right: { fromLeft: false, range: range2 },
+      }
+    }
+  }
+  if (max1.num <= max2.num) {
+    let hasRight = true
+    let isLeftRangeOverride = false
+
+    if (max1.num === max2.num) {
+      const exclusive1 = max1.exclusive
+      const exclusive2 = max2.exclusive
+      hasRight = exclusive1 !== exclusive2
+      isLeftRangeOverride = !exclusive1 && exclusive2
+    }
+    if (!isLeftRangeOverride) {
+      let right: SplitterSide | undefined
+      if (hasRight) {
+        right = {
+          fromLeft: false,
+          range: [reversalExclusive(max1), max2],
+        }
+      }
+      return {
+        left: {
+          fromLeft: true,
+          range: [min1, reversalExclusive(min2)],
+        },
+        center: [min2, max1],
+        right,
+      }
+    }
+  }
+  // if (max1.num > max2.num || (max1.num === max2.num && max1.exclusive === false && max2.exclusive === true))
+  {
+    return {
+      left: {
+        fromLeft: true,
+        range: [min1, reversalExclusive(min2)],
+      },
+      center: [min2, max2],
+      right: {
+        fromLeft: true,
+        range: [reversalExclusive(max2), max1],
+      },
+    }
+  }
+}
+
+function splitRangeGreaterBranch(range1: Range, range2: Range): Splitter {
+  const [min1, max1] = range1
+  const [min2, max2] = range2
+
+  if (min1.num >= max2.num) {
+    const exclusive1 = max2.exclusive
+    const exclusive2 = min1.exclusive
+    if (min1.num > max2.num || exclusive1 || exclusive2) {
+      return {
+        left: { fromLeft: false, range: range2 },
+        right: { fromLeft: true, range: range1 },
+      }
+    }
+  }
+  if (max2.num <= max1.num) {
+    let hasRight = true
+    let isRightRangeOverride = false
+
+    if (max1.num === max2.num) {
+      const exclusive1 = max2.exclusive
+      const exclusive2 = max1.exclusive
+      hasRight = exclusive1 !== exclusive2
+      isRightRangeOverride = !exclusive1 && exclusive2
+    }
+    if (!isRightRangeOverride) {
+      let right: SplitterSide | undefined
+      if (hasRight) {
+        right = {
+          fromLeft: true,
+          range: [reversalExclusive(max2), max1],
+        }
+      }
+      return {
+        left: {
+          fromLeft: false,
+          range: [min2, reversalExclusive(min1)],
+        },
+        center: [min1, max2],
+        right,
+      }
+    }
+  }
+  // if (max2.num > max1.num || (max2.num === max1.num && max2.exclusive === false && max1.exclusive === true))
+  {
+    return {
+      left: {
+        fromLeft: false,
+        range: [min2, reversalExclusive(min1)],
+      },
+      center: [min1, max1],
+      right: {
+        fromLeft: false,
+        range: [reversalExclusive(max1), max2],
+      },
+    }
+  }
+}
+
+function splitRangeEqualsBranch(range1: Range, range2: Range): Splitter {
+  const [min1, max1] = range1
+  const [min2, max2] = range2
+  const exclusive1 = min1.exclusive
+  const exclusive2 = min2.exclusive
+
+  let left: SplitterSide | undefined
+  let centerBegin = min1
+
+  if (!exclusive1 && exclusive2) {
+    centerBegin = min2
+    left = {
+      fromLeft: true,
+      range: [min1, reversalExclusive(min2)],
+    }
+  } else if (exclusive1 && !exclusive2) {
+    left = {
+      fromLeft: false,
+      range: [min2, reversalExclusive(min1)],
+    }
+  }
+  if (max1.num <= max2.num) {
+    let hasRight = true
+    let isLeftRangeOverride = false
+    if (max1.num === max2.num) {
+      const maxExclusive1 = max1.exclusive
+      const maxExclusive2 = max2.exclusive
+      hasRight = maxExclusive1 !== maxExclusive2
+      isLeftRangeOverride = !maxExclusive1 && maxExclusive2
+    }
+    if (!isLeftRangeOverride) {
+      let right: SplitterSide | undefined
+      if (hasRight) {
+        right = {
+          fromLeft: false,
+          range: [reversalExclusive(max1), max2],
+        }
+      }
+      return {
+        left,
+        center: [centerBegin, max1],
+        right,
+      }
+    }
+  }
+  // if (max1.num > max2.num || (max1.num === max2.num && max1.exclusive === false && max2.exclusive === true))
+  {
+    return {
+      left,
+      center: [centerBegin, max2],
+      right: {
+        fromLeft: true,
+        range: [reversalExclusive(max2), max1],
+      },
+    }
+  }
+}
+
+function reversalExclusive(point: Point): Point {
+  return {
+    num: point.num,
+    exclusive: !point.exclusive,
+  }
+}

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

@@ -0,0 +1,23 @@
+import type { CompiledSchema } from '../compiler/index.ts'
+
+export const ValidResult = Object.freeze({
+  Valid: 0,
+  Invalid: 1,
+  Unknown: 2,
+})
+
+export type ValidResult = (typeof ValidResult)[keyof typeof ValidResult]
+
+export function valid<E>(compiledSchema: CompiledSchema<E>, value: unknown): ValidResult {
+  const isValid = compiledSchema.isValid
+  if (isValid) {
+    const result = isValid(value)
+    if (result === true) {
+      return ValidResult.Valid
+    } else {
+      return ValidResult.Invalid
+    }
+  } else {
+    return ValidResult.Unknown
+  }
+}

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

@@ -0,0 +1,163 @@
+import type { JSONSchema7, JSONSchema7Definition } from 'json-schema'
+import type { JSONDelegate } from '../types.ts'
+import type { Schema } from '../types.ts'
+import type { Context } from './common.ts'
+import type { InputSchema } from './compiler.ts'
+import type { CompiledSchema } from './wrapper.ts'
+
+import { joinPath, recordWarn, unwrapJSONSchema7Definition } from './common.ts'
+import { compileSchema } from './compiler.ts'
+import { cleanEmptyValues } from './utils.ts'
+import { wrapCompiledSchema, CompiledKind, getKind, toNever, isCompiledSchema } from './wrapper.ts'
+
+export function compileArraySchema<E>(context: Context<E>, schema: InputSchema): CompiledSchema<E> | null {
+  let items = compileItems(context, schema)
+  let maxItems = getItemsLimit(context, 'maxItems', schema)
+  const minItems = getItemsLimit(context, 'minItems', schema)
+  const contains = compileContains(context, schema)
+  const uniqueItems = schema.uniqueItems
+
+  // Undefined means no value is required, while null represents a compilation error.
+  let additionalItems: Schema<E> | false | null | undefined
+
+  if (Array.isArray(items)) {
+    additionalItems = compileAdditionalItems(context, schema)
+  } else if (schema.additionalItems) {
+    // Additional items are ignored when items is not an array.
+    // See https://datatracker.ietf.org/doc/html/draft-handrews-json-schema-validation-01#section-6.4.2.
+    recordWarn(context, 'it is needless when items is not array', 'additionalItems')
+  }
+  if (!items || !contains || additionalItems === null) {
+    return null
+  }
+  let isNever = false
+  let updateMaxItems = false
+
+  if (Array.isArray(items)) {
+    if (maxItems !== undefined && maxItems <= items.length) {
+      items = items.splice(maxItems)
+      additionalItems = variableToNever(additionalItems, context.delegate)
+    }
+    const firstNeverItemIndex = items.findIndex((item) => getKind(item) === CompiledKind.Never)
+
+    if (firstNeverItemIndex !== -1) {
+      items = items.splice(firstNeverItemIndex)
+      additionalItems = variableToNever(additionalItems, context.delegate)
+      if (maxItems === undefined) {
+        maxItems = items.length
+        updateMaxItems = true
+      }
+    }
+    if (minItems !== undefined && items.length < minItems) {
+      recordWarn(context, `length(${items.length}) of items if less than minItems(${minItems})`)
+      isNever = true
+    }
+    if (items.length === 0 && additionalItems && getKind(additionalItems) === CompiledKind.Never) {
+      isNever = true
+    }
+  } else if (getKind(items) === CompiledKind.Never) {
+    isNever = true
+  }
+  if (maxItems !== undefined && minItems !== undefined && maxItems < minItems) {
+    if (!updateMaxItems) {
+      recordWarn(context, `maxItems(${maxItems}) is less than minItems(${minItems})`)
+    }
+    isNever = true
+  }
+  const kind = isNever ? CompiledKind.Never : CompiledKind.Array
+  const mergedSchema = cleanEmptyValues({
+    type: 'array',
+    items,
+    contains,
+    uniqueItems,
+    maxItems,
+    minItems,
+    additionalItems: additionalItems!,
+  })
+  return wrapCompiledSchema(kind, mergedSchema as JSONSchema7, context.delegate, context.path)
+}
+
+function compileItems<E>(context: Context<E>, { items }: InputSchema): Schema<E> | Schema<E>[] | null {
+  if (!items) {
+    return wrapCompiledSchema(CompiledKind.Any, {}, context.delegate, context.path)
+  }
+  if (Array.isArray(items)) {
+    const schemas: Schema<E>[] = []
+    let hasAnyError = false
+    for (const [i, item] of items.entries()) {
+      const subContext = joinPath(context, 'items', i)
+      const schema = compileSchema(subContext, unwrapJSONSchema7Definition(item))
+      if (!schema) {
+        hasAnyError = true
+        continue
+      }
+      schemas.push(schema)
+    }
+    if (hasAnyError) {
+      return null
+    }
+    return schemas
+  } else {
+    const subContext = joinPath(context, 'items')
+    const itemsSchema = unwrapJSONSchema7Definition(items as JSONSchema7Definition)
+    const schema = compileSchema(subContext, itemsSchema)
+
+    return schema
+  }
+}
+
+function getItemsLimit<E>(context: Context<E>, name: 'maxItems' | 'minItems', schema: InputSchema): number | undefined {
+  const propertiesLimit = schema[name]
+  if (propertiesLimit === undefined) {
+    return undefined
+  }
+  if (Number.isNaN(propertiesLimit)) {
+    recordWarn(context, 'find NaN', name)
+    return undefined
+  }
+  if (propertiesLimit < 0) {
+    recordWarn(context, `find invalid number ${propertiesLimit}`, name)
+    return undefined
+  }
+  return propertiesLimit
+}
+
+function compileContains<E>(context: Context<E>, { contains }: InputSchema): Schema<E> | null {
+  if (!contains) {
+    return wrapCompiledSchema(CompiledKind.Any, {}, context.delegate, context.path)
+  }
+  const subContext = joinPath(context, 'contains')
+  const containsSchema = unwrapJSONSchema7Definition(contains)
+
+  return compileSchema(subContext, containsSchema)
+}
+
+function compileAdditionalItems<E>(context: Context<E>, { additionalItems }: InputSchema): Schema<E> | false | null {
+  switch (typeof additionalItems) {
+    case 'boolean': {
+      if (additionalItems) {
+        return wrapCompiledSchema(CompiledKind.Any, {}, context.delegate, context.path)
+      } else {
+        return false
+      }
+    }
+    case 'object': {
+      const subContext = joinPath(context, 'additionalItems')
+      const compiledSchema = compileSchema(subContext, additionalItems)
+      return compiledSchema
+    }
+    default: {
+      return wrapCompiledSchema(CompiledKind.Any, {}, context.delegate, context.path)
+    }
+  }
+}
+
+function variableToNever<T, E>(schema: Schema<E> | T | undefined, delegate?: JSONDelegate<E>): Schema<E> | T {
+  if (schema === undefined) {
+    return wrapCompiledSchema(CompiledKind.Never, { type: 'string', maxLength: 0, minLength: 1 }, delegate)
+  } else if (isCompiledSchema(schema)) {
+    return getKind(schema) === CompiledKind.Never ? schema : toNever(schema as CompiledSchema<E>)
+  } else {
+    return schema
+  }
+}

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

@@ -0,0 +1,109 @@
+import type { JSONSchema7Definition } from 'json-schema'
+import type { Schema } from '../types.ts'
+import type { JSONDelegate } from '../types.ts'
+import type { DeepReadonly } from '../utils.ts'
+import type { Context } from './common.ts'
+import type { CompiledSchema } from './wrapper.ts'
+
+import { joinPath, unwrapJSONSchema7Definition, recordError } from './common.ts'
+import { compileSchema } from './compiler.ts'
+import { getKind, CompiledKind, wrapCompiledSchema } from './wrapper.ts'
+
+export type CombinationKeys = 'allOf' | 'anyOf' | 'oneOf'
+export const COMBINATION_KEYS: readonly CombinationKeys[] = Object.freeze(['allOf', 'anyOf', 'oneOf'])
+
+export function compileCombinationSchema<E>(
+  context: Context<E>,
+  key: CombinationKeys,
+  combinationList: DeepReadonly<JSONSchema7Definition[]>,
+  delegate?: JSONDelegate<E>,
+): CompiledSchema<E> | null {
+  if (combinationList.length === 0) {
+    recordError(context, 'disable empty list', key)
+    return null
+  }
+  const compiledCombinationList: Schema<E>[] = []
+
+  for (const [i, element] of combinationList.entries()) {
+    const subContext = joinPath(context, key, i)
+    const schema = unwrapJSONSchema7Definition(element)
+    const compiledSchema = compileSchema(subContext, schema)
+    if (compiledSchema) {
+      compiledCombinationList.push(compiledSchema)
+    }
+  }
+  if (compiledCombinationList.length < combinationList.length) {
+    return null
+  }
+  let anyCount = 0
+  let neverCount = 0
+
+  for (const compiledSchema of compiledCombinationList) {
+    switch (getKind(compiledSchema)) {
+      case CompiledKind.Any: {
+        anyCount += 1
+        break
+      }
+      case CompiledKind.Never: {
+        neverCount += 1
+        break
+      }
+    }
+  }
+  let kind: CompiledKind = CompiledKind.Combination
+
+  switch (key) {
+    case 'allOf': {
+      if (neverCount > 0) {
+        kind = CompiledKind.Never
+      } else if (anyCount === compiledCombinationList.length) {
+        kind = CompiledKind.Any
+      } else if (!areAllTypesTheSame(compiledCombinationList)) {
+        kind = CompiledKind.Never
+      }
+      break
+    }
+    case 'anyOf': {
+      if (anyCount > 0) {
+        kind = CompiledKind.Any
+      } else if (neverCount === compiledCombinationList.length) {
+        kind = CompiledKind.Never
+      }
+      break
+    }
+    case 'oneOf': {
+      if (anyCount > 1) {
+        // More than one unconstrained branch violates oneOf because at least two branches will match.
+        kind = CompiledKind.Never
+      } else if (neverCount === compiledCombinationList.length) {
+        kind = CompiledKind.Never
+      } else if (anyCount === 1 && neverCount === compiledCombinationList.length - 1) {
+        kind = CompiledKind.Any
+      }
+      break
+    }
+  }
+  return wrapCompiledSchema(kind, { [key]: compiledCombinationList }, delegate, context.path)
+}
+
+function areAllTypesTheSame<E>(combinationList: Schema<E>[]): boolean {
+  let lastKind: CompiledKind | null = null
+  for (const schema of combinationList) {
+    const kind = getKind(schema)
+    switch (kind) {
+      case CompiledKind.Any:
+      case CompiledKind.Never: {
+        break
+      }
+      default: {
+        if (lastKind === null) {
+          lastKind = kind
+        } else if (lastKind !== kind) {
+          return false
+        }
+        break
+      }
+    }
+  }
+  return true
+}

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

@@ -0,0 +1,99 @@
+import type { JSONSchema7, JSONSchema7Definition } from 'json-schema'
+import type { SchemaErrorItem } from '../error.ts'
+import type { ExtendsContext } from '../extends/index.ts'
+import type { JSONDelegate } from '../types.ts'
+
+import { SchemaErrorItemKind } from '../error.ts'
+
+const jsonSchemaKeys: Set<string> = new Set([
+  'type',
+  'enum',
+  'const',
+  'multipleOf',
+  'maximum',
+  'exclusiveMaximum',
+  'minimum',
+  'exclusiveMinimum',
+  'maxLength',
+  'minLength',
+  'pattern',
+  'items',
+  'additionalItems',
+  'maxItems',
+  'minItems',
+  'uniqueItems',
+  'contains',
+  'maxProperties',
+  'minProperties',
+  'required',
+  'properties',
+  'patternProperties',
+  'additionalProperties',
+  'dependencies',
+  'propertyNames',
+  'if',
+  'then',
+  'else',
+  'allOf',
+  'anyOf',
+  'oneOf',
+  'not',
+  'format',
+  'contentMediaType',
+  'contentEncoding',
+  'definitions',
+])
+
+export function isJSONSchemaKey(key: string): key is keyof JSONSchema7 {
+  return jsonSchemaKeys.has(key)
+}
+
+export function isLogicEmptyObject(object: object): boolean {
+  for (const key in object) {
+    if (isJSONSchemaKey(key)) {
+      return false
+    }
+  }
+  return true
+}
+
+export type Context<E> = {
+  readonly delegate?: JSONDelegate<E>
+  readonly payload?: unknown
+  readonly extends: ExtendsContext
+  readonly path: readonly (string | number)[]
+  readonly errors: SchemaErrorItem<E>[]
+  readonly warns: SchemaErrorItem<E>[]
+}
+
+export function joinPath<E>(context: Context<E>, ...extraPath: (string | number)[]): Context<E> {
+  return {
+    ...context,
+    path: [...context.path, ...extraPath],
+  }
+}
+
+export function unwrapJSONSchema7Definition<T>(schema: T): T extends JSONSchema7Definition ? JSONSchema7 : T {
+  if (typeof schema === 'boolean') {
+    // This compiler deliberately rejects boolean schemas even though JSONSchema7Definition includes them.
+    throw new Error('JSONSchema7Definition cannot be boolean')
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return schema as any
+}
+
+export function recordError<E>({ path, errors }: Context<E>, message: string, ...extraPath: (string | number)[]): void {
+  errors.push(createSchemaError(path, extraPath, message))
+}
+
+export function recordWarn<E>({ path, warns }: Context<E>, message: string, ...extraPath: (string | number)[]): void {
+  warns.push(createSchemaError(path, extraPath, message))
+}
+
+function createSchemaError<E>(path: readonly (string | number)[], extraPath: (string | number)[], message: string): SchemaErrorItem<E> {
+  return {
+    kind: SchemaErrorItemKind.Compiled,
+    message,
+    path: [...path, ...extraPath],
+  }
+}