@based/schema 2.0.0 → 2.1.0

package/src/walker/index.ts

@@ -1,48 +0,0 @@
-import { BasedSchema } from '../types'
-import { ArgsClass } from './args'
-import { AsyncOperation, Opts } from './types'
-
-export const walk = async <T>(
-  schema: BasedSchema,
-  opts: Opts<T>,
-  value: any,
-  asyncOperationHandler?: AsyncOperation<T>
-): Promise<T> => {
-  if (!('collect' in opts)) {
-    opts.collect = () => {}
-  }
-
-  if (!('error' in opts)) {
-    opts.error = () => {}
-  }
-
-  if (asyncOperationHandler) {
-    opts = {
-      ...opts,
-      asyncOperationHandler,
-    }
-  }
-
-  const argsOpts = await opts.init(value, schema, opts.error)
-
-  if (!argsOpts) {
-    return <T>{}
-  }
-
-  if (!argsOpts.value) {
-    argsOpts.value = value
-  }
-
-  const args = new ArgsClass(argsOpts)
-  args.root = args
-  args._opts = opts
-  args._schema = schema
-
-  await args.parse()
-
-  return args.target
-}
-
-export { ArgsClass }
-
-export * from './types'

package/src/walker/parse.ts

@@ -1,233 +0,0 @@
-import { deepEqual } from '@saulx/utils'
-import {
-  BasedSchemaField,
-  BasedSchemaFieldObject,
-  BasedSchemaFieldRecord,
-  BasedSchemaFields,
-} from '../types'
-import { ArgsClass } from './args'
-import { ArgsOpts, FieldParser, KeyParser, Stopped } from './types'
-
-export type ParseResult<T> = ArgsClass<T> | void
-
-// TODO needs cleaning
-function createOrUseArgs<T>(
-  from: ArgsClass<T>,
-  newArgs: ArgsClass<T> | ArgsOpts<T> | void
-): ParseResult<T> {
-  if (!newArgs) {
-    return
-  }
-  if (newArgs instanceof ArgsClass) {
-    return newArgs
-  }
-
-  const x = from.create(newArgs)
-
-  // x.collectedCommands = from.collectedCommands
-  // x.fromBackTrack = from.fromBackTrack
-
-  return x
-}
-
-async function parseKey<T>(
-  from: ArgsClass<T>,
-  key: string | number,
-  parser: KeyParser<T>
-): Promise<ParseResult<T>> {
-  const keyArgs = new ArgsClass(
-    {
-      key,
-      value: from.value[key],
-      fieldSchema: from.fieldSchema,
-    },
-    from
-  )
-
-  // if same
-
-  const newArgs = createOrUseArgs(keyArgs, await parser(keyArgs))
-
-  if (newArgs) {
-    return newArgs.parse()
-  }
-}
-
-function createFieldArgs<T>(
-  from: ArgsClass<T>,
-  key: string | number,
-  fieldSchema: BasedSchemaField
-): ArgsClass<T> {
-  return new ArgsClass(
-    {
-      key,
-      value: from.value[key],
-      // @ts-ignore needs key
-      fieldSchema,
-    },
-    from
-  )
-}
-
-function getFieldParser<T>(
-  args: ArgsClass<T>
-): void | FieldParser<keyof BasedSchemaFields> {
-  const fieldParser =
-    'enum' in args.fieldSchema
-      ? args.root._opts.parsers.fields.enum
-      : args.root._opts.parsers.fields[args.fieldSchema.type]
-  return fieldParser
-}
-
-export async function parse<T>(
-  args: ArgsClass<T>
-): Promise<ArgsClass<T> | void> {
-  const opts = args.root._opts
-
-  if (args.parseTopLevel) {
-    const parser = opts.parsers.any
-    if (parser) {
-      const nArgs = await parser(args)
-
-      if (nArgs) {
-        // @ts-ignore
-        return parse(createOrUseArgs(args, nArgs))
-      }
-    }
-  }
-
-  if (typeof args.value === 'object' && args.value !== null) {
-    const keyQ: Promise<ParseResult<T>>[] = []
-    const keysHandled: Set<string | number> = new Set()
-    let allKeysHandled = false
-
-    for (const key in opts.parsers.keys) {
-      if (key in args.value) {
-        keysHandled.add(key)
-        keyQ.push(parseKey(args, key, opts.parsers.keys[key]))
-      }
-    }
-    await Promise.all(keyQ)
-
-    if (typeof args.value !== 'object' || args.value === null) {
-      return
-    }
-
-    // schema
-    if (args.stopped === undefined) {
-      const fieldQ: Promise<ParseResult<T>>[] = []
-      if (args.typeSchema && !args.fieldSchema) {
-        for (const key in args.typeSchema.fields) {
-          const fieldSchema = args.typeSchema.fields[key]
-          if (key in args.value) {
-            keysHandled.add(key)
-            fieldQ.push(createFieldArgs(args, key, fieldSchema).parse())
-          }
-        }
-      } else if (args.fieldSchema && !args.stopped) {
-        if (args.fieldSchema.type === 'object') {
-          // @ts-ignore should detect from line above
-          const objFieldSchema: BasedSchemaFieldObject = args.fieldSchema
-          for (const key in objFieldSchema.properties) {
-            const fieldSchema = objFieldSchema.properties[key]
-            if (key in args.value) {
-              keysHandled.add(key)
-              fieldQ.push(createFieldArgs(args, key, fieldSchema).parse())
-            }
-          }
-        } else if (args.fieldSchema.type === 'record') {
-          // @ts-ignore should detect from line above
-          const objFieldSchema: BasedSchemaFieldRecord = args.fieldSchema
-          for (const key in args.value) {
-            const fieldSchema = objFieldSchema.values
-            keysHandled.add(key)
-            fieldQ.push(createFieldArgs(args, key, fieldSchema).parse())
-          }
-        } else if (args.fieldSchema) {
-          const fieldParser = getFieldParser(args)
-          if (fieldParser) {
-            const newArgs = createOrUseArgs(args, await fieldParser(args))
-            if (newArgs) {
-              return newArgs.parse()
-            }
-          }
-        }
-      }
-      await Promise.all(fieldQ)
-      if (
-        args.fieldSchema &&
-        fieldQ.length > 0 &&
-        (args.fieldSchema.type === 'object' ||
-          args.fieldSchema.type === 'record')
-      ) {
-        const fieldParser = getFieldParser(args)
-        if (fieldParser) {
-          fieldParser(args)
-        }
-      }
-    }
-
-    if (typeof args.value !== 'object' || args.value === null) {
-      return
-    }
-
-    // any
-    if (args.stopped !== Stopped.stopAll) {
-      const parser = opts.parsers.any || opts.parsers.catch
-      if (parser) {
-        const q: Promise<ParseResult<T>>[] = []
-        if (Array.isArray(args.value)) {
-          for (let i = 0; i < args.value.length; i++) {
-            if ((!opts.parsers.any && keysHandled.has(i)) || allKeysHandled) {
-              continue
-            }
-            q.push(parseKey(args, i, parser))
-          }
-        } else {
-          for (const key in args.value) {
-            if ((!opts.parsers.any && keysHandled.has(key)) || allKeysHandled) {
-              continue
-            }
-            q.push(parseKey(args, key, parser))
-          }
-        }
-        await Promise.all(q)
-      }
-    }
-
-    if (
-      opts.backtrack &&
-      !args.skipCollection &&
-      (args.fromBackTrack.length || args.collectedCommands.length)
-    ) {
-      const backtracked = opts.backtrack(
-        args,
-        args.fromBackTrack ?? [],
-        args.collectedCommands ?? []
-      )
-      if (backtracked) {
-        const target = args.getBackTrackTarget()
-        if (!target.fromBackTrack) {
-          target.fromBackTrack = []
-        }
-        target.fromBackTrack.push(backtracked)
-      }
-    }
-  } else {
-    // more
-    if (args.fieldSchema) {
-      const fieldParser = getFieldParser(args)
-      if (fieldParser) {
-        const newArgs = createOrUseArgs(args, await fieldParser(args))
-        if (newArgs) {
-          return newArgs.parse()
-        }
-      } else {
-        console.warn('fieldSchema type not implemented yet!', args.fieldSchema)
-        const anyParser = opts.parsers.any || opts.parsers.catch
-        anyParser(args)
-      }
-    } else {
-    }
-  }
-}

package/src/walker/types.ts

@@ -1,81 +0,0 @@
-import { ParseError } from '../error'
-import {
-  BasedSchemaType,
-  BasedSchemaFields,
-  BasedSchemaField,
-  BasedSchema,
-} from '../types'
-import { ArgsClass } from './args'
-
-export type Path = (string | number)[]
-
-export type ErrorHandler<T> = (
-  code: ParseError,
-  args: ArgsClass<T> | ArgsOpts<T>
-) => void
-
-export type Collect<T> = (args: ArgsClass<T>) => any
-
-export type FieldParser<K extends keyof BasedSchemaFields, T = any> = (
-  args: ArgsClass<T, K>
-) => Promise<ArgsClass<T> | ArgsOpts<T> | void>
-
-export type KeyParser<T = any> = (
-  args: ArgsClass<T, keyof BasedSchemaFields>
-) => Promise<ArgsOpts<T> | ArgsClass<T> | void>
-
-export type FieldParsers<T = any> = {
-  [Key in keyof BasedSchemaFields]: FieldParser<Key, T>
-}
-
-export type AsyncOperation<T> = (
-  args: ArgsClass<T>,
-  type?: string
-) => Promise<any>
-
-export type Opts<T> = {
-  init: (
-    value: any,
-    schema: BasedSchema,
-    error: ErrorHandler<T>
-  ) => Promise<ArgsOpts<T>>
-  parsers: {
-    fields: Partial<{
-      [Key in keyof BasedSchemaFields]: FieldParser<Key, T>
-    }>
-    keys: { [key: string]: KeyParser<T> }
-    any?: KeyParser<T>
-    catch?: KeyParser<T>
-  }
-  collect?: (args: ArgsClass<T>) => any
-  error?: ErrorHandler<T>
-  backtrack?: (
-    args: ArgsClass<T>,
-    fromBackTrack: any[],
-    collectedCommands: any[]
-  ) => any
-  asyncOperationHandler?: AsyncOperation<T>
-}
-
-export enum Stopped {
-  onlyStopFieldParser,
-  stopAll,
-}
-
-export type ArgsOpts<
-  T,
-  K extends keyof BasedSchemaFields = keyof BasedSchemaFields
-> = {
-  parseTopLevel?: boolean
-  target?: T
-  key?: string | number
-  path?: Path
-  value?: any
-  prev?: ArgsClass<T, K>
-  fieldSchema?: BasedSchemaField
-  typeSchema?: BasedSchemaType
-  skipCollection?: boolean
-  collect?: (args: ArgsClass<T, K>, value?: any) => any
-}
-
-// Add asyncOperations // requiresAsyncValidation -> asyncOperation: () => {}