@based/schema 2.0.0 → 2.2.0

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: () => {}

package/test/array.ts

@@ -1,388 +0,0 @@
-import test from 'ava'
-import { BasedSchema, setWalker } from '../src/index'
-import { errorCollect, resultCollect } from './utils'
-
-const schema: BasedSchema = {
-  types: {
-    bla: {
-      prefix: 'bl',
-      fields: {
-        arrNum: {
-          type: 'array',
-          values: {
-            type: 'number',
-          },
-        },
-        objArray: {
-          type: 'array',
-          values: {
-            type: 'object',
-            properties: {
-              snurp: {
-                type: 'string',
-              },
-            },
-          },
-        },
-        arrStr: {
-          type: 'array',
-          values: {
-            type: 'string',
-          },
-        },
-        intarray: {
-          type: 'array',
-          values: {
-            type: 'integer',
-          },
-        },
-      },
-    },
-  },
-  $defs: {},
-  language: 'en',
-  root: {
-    fields: {},
-  },
-  prefixToTypeMapping: {
-    bl: 'bla',
-  },
-}
-
-test('arrayNum', async (t) => {
-  const err = await setWalker(schema, {
-    $id: 'bl1',
-    arrNum: ['1', '2'],
-  })
-  const err1 = await setWalker(schema, {
-    $id: 'bla',
-    ref: 1,
-  })
-
-  const res = await setWalker(schema, {
-    $id: 'bla',
-    arrNum: [1, 2],
-  })
-
-  t.true(errorCollect(err, err1).length > 0)
-
-  t.deepEqual(resultCollect(res), [
-    { path: ['arrNum'], value: { $delete: true } },
-    { path: ['arrNum', 0], value: 1 },
-    { path: ['arrNum', 1], value: 2 },
-  ])
-})
-
-test('value arr', async (t) => {
-  const err = await setWalker(schema, {
-    $id: 'bl1',
-    arrNum: { $value: ['1', '2'] },
-  })
-
-  t.true(err.errors.length > 1)
-
-  const res = await setWalker(schema, {
-    $id: 'bla',
-    arrNum: [{ $value: 1 }, { $value: 2 }],
-  })
-  const res1 = await setWalker(schema, {
-    $id: 'bla',
-    arrNum: { $value: [1, 2] },
-  })
-
-  t.deepEqual(resultCollect(res, res1), [
-    { path: ['arrNum'], value: { $delete: true } },
-    { path: ['arrNum', 0], value: 1 },
-    { path: ['arrNum', 1], value: 2 },
-    { path: ['arrNum'], value: { $delete: true } },
-    { path: ['arrNum', 0], value: 1 },
-    { path: ['arrNum', 1], value: 2 },
-  ])
-})
-
-test.only('default arr', async (t) => {
-  const err = await setWalker(schema, {
-    $id: 'bl1',
-    arrNum: ['1', '2'],
-  })
-  const err1 = await setWalker(schema, {
-    $id: 'bla',
-    ref: 1,
-  })
-
-  const res = await setWalker(schema, {
-    $id: 'bla',
-    arrNum: [{ $default: 1 }, { $default: 2 }],
-  })
-  const res1 = await setWalker(schema, {
-    $id: 'bla',
-    arrNum: { $default: [1, 2] },
-  })
-
-  t.true(errorCollect(err, err1).length > 0)
-
-  t.deepEqual(resultCollect(res, res1), [
-    { path: ['arrNum'], value: { $delete: true } },
-    { path: ['arrNum', 0], value: { $default: 1 } },
-    { path: ['arrNum', 1], value: { $default: 2 } },
-    // TODO bit sketchy needs some work
-    { path: ['arrNum'], value: { $default: [1, 2] } },
-  ])
-})
-
-let r
-
-test('assign idx value', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    intarray: {
-      $assign: {
-        $idx: 0,
-        $value: 6,
-      },
-    },
-  })
-
-  t.deepEqual(resultCollect(r), [{ path: ['intarray', 0], value: 6 }])
-})
-
-test('push ints', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    intarray: {
-      $push: [1, 2, 3, 4, 5],
-    },
-  })
-
-  t.deepEqual(resultCollect(r), [
-    { path: ['intarray'], value: { $push: [1, 2, 3, 4, 5] } },
-  ])
-})
-
-test('push objs', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    objArray: {
-      $push: [{ snurp: 'a' }, { snurp: 'b' }, { snurp: 'c' }],
-    },
-  })
-
-  t.deepEqual(resultCollect(r), [
-    {
-      path: ['objArray'],
-      value: {
-        $push: [{ snurp: 'a' }, { snurp: 'b' }, { snurp: 'c' }],
-      },
-    },
-    { path: ['objArray', -3, 'snurp'], value: 'a' },
-    { path: ['objArray', -2, 'snurp'], value: 'b' },
-    { path: ['objArray', -1, 'snurp'], value: 'c' },
-    { path: ['objArray', -3], value: { snurp: 'a' } },
-    { path: ['objArray', -2], value: { snurp: 'b' } },
-    { path: ['objArray', -1], value: { snurp: 'c' } },
-  ])
-})
-
-test('unshift ints', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    intarray: {
-      $unshift: [1, 2, 3, 4, 5],
-    },
-  })
-
-  t.deepEqual(resultCollect(r), [
-    { path: ['intarray'], value: { $unshift: [1, 2, 3, 4, 5] } },
-  ])
-  t.true(true)
-})
-
-test('nested default unshift', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    intarray: {
-      $unshift: [{ $value: 1 }, { $default: 2 }, 3, 4, 5],
-    },
-  })
-
-  t.is(r.errors.length, 0)
-
-  t.deepEqual(resultCollect(r), [
-    {
-      path: ['intarray'],
-      value: { $unshift: [1, { $default: 2 }, 3, 4, 5] },
-    },
-  ])
-})
-
-test('nested default in push', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    intarray: {
-      $push: [{ $value: 1 }, { $default: 2 }, 3, 4, 5],
-    },
-  })
-
-  t.is(r.errors.length, 0)
-
-  t.deepEqual(resultCollect(r), [
-    {
-      path: ['intarray'],
-      value: { $push: [1, { $default: 2 }, 3, 4, 5] },
-    },
-  ])
-})
-
-test('assign idx default value error', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    intarray: {
-      $assign: {
-        $idx: { $default: 0 },
-        $value: 6,
-      },
-    },
-  })
-  t.true(r.errors.length > 0)
-})
-
-test('assign idx no value', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    intarray: {
-      $assign: {
-        $idx: { $default: 0 },
-      },
-    },
-  })
-  t.true(r.errors.length > 0)
-})
-
-test('assign idx value spelled wrong', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    intarray: {
-      $assign: {
-        $idx: 0,
-        value: 5,
-      },
-    },
-  })
-
-  t.true(r.errors.length > 0)
-})
-
-test('assign idx value wrong type', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    intarray: {
-      $assign: {
-        $idx: 0,
-        $value: 5.6,
-      },
-    },
-  })
-
-  t.true(r.errors.length > 0)
-})
-
-test('assign idx value value wrong type', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    intarray: {
-      $assign: {
-        $idx: 0,
-        $value: { $value: 5.6 },
-      },
-    },
-  })
-
-  t.true(r.errors.length > 0)
-})
-
-test('assign idx default value', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    intarray: {
-      $assign: {
-        $idx: 0,
-        $value: { $default: 5 },
-      },
-    },
-  })
-
-  t.deepEqual(resultCollect(r), [
-    { path: ['intarray', 0], value: { $default: 5 } },
-  ])
-})
-
-test('assign idx value value error', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    intarray: {
-      $assign: {
-        $idx: { $value: 0 },
-        $value: 6,
-      },
-    },
-  })
-
-  t.true(r.errors.length > 0)
-})
-
-test('insert idx intarray', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    intarray: {
-      $insert: {
-        $idx: 10,
-        $value: 1212,
-      },
-    },
-  })
-
-  t.true(r.errors.length === 0)
-  t.deepEqual(resultCollect(r), [
-    {
-      path: ['intarray'],
-      value: { $insert: { $idx: 10, $value: [1212] } },
-    },
-  ])
-})
-
-test('unshift array', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    intarray: {
-      $unshift: { $value: [-10, -20, -30] },
-    },
-  })
-
-  t.true(r.errors.length === 0)
-  t.deepEqual(resultCollect(r), [
-    { path: ['intarray'], value: { $unshift: [-10, -20, -30] } },
-  ])
-})
-
-test('assign + $delete', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    objArray: {
-      $assign: {
-        $idx: 3,
-        $value: {
-          snurp: {
-            $delete: true,
-          },
-        },
-      },
-    },
-  })
-
-  t.is(r.errors.length, 0)
-
-  t.deepEqual(resultCollect(r), [
-    { path: ['objArray', 3, 'snurp'], value: { $delete: true } },
-    { path: ['objArray', 3], value: { snurp: { $delete: true } } },
-  ])
-})