@based/schema 0.0.16 → 1.0.2

package/src/walker.ts

@@ -1,201 +0,0 @@
-import { ParseError } from './set/error'
-import { BasedSchema, BasedSetHandlers, BasedSetTarget } from './types'
-import { BasedSchemaType, BasedSchemaFields } from './types'
-
-type Path = (string | number)[]
-
-type ErrorHandler<T> = (args: Args<T>, code: ParseError) => void
-
-type Parse<T> = (
-  args: Args<T>,
-  key?: string | number,
-  value?: any
-) => Promise<Args<T> | void> // If true will not continue
-
-type BackTrack<T> = (
-  args: Args<T>,
-  fromBackTrack: any[],
-  collectedCommands: any[]
-) => any
-
-export type Args<
-  T,
-  K extends keyof BasedSchemaFields = keyof BasedSchemaFields
-> = {
-  schema: BasedSchema
-  parentValue?: any
-  skipCollection?: boolean
-  fieldSchema?: BasedSchemaFields[K]
-  typeSchema?: BasedSchemaType
-  path: Path
-  key?: number | string
-  value: any
-  target: T
-  fromBackTrack: any[]
-  parse: Parse<T>
-  collect: (args: Args<T>) => any
-  backtrack: BackTrack<T>
-  requiresAsyncValidation: (validationType: any) => Promise<any>
-  error: ErrorHandler<T>
-}
-
-export type FieldParser<K extends keyof BasedSchemaFields, T = any> = (
-  args: Args<T, K>
-) => Promise<Args<T> | void>
-
-export type KeyParser<T = any> = (
-  args: Args<T, keyof BasedSchemaFields>
-) => Promise<Args<T> | void>
-
-export type Opts<T> = {
-  schema: BasedSchema
-  init: (args: Args<T>) => Promise<Args<T>>
-  parsers: {
-    fields: Partial<{
-      [Key in keyof BasedSchemaFields]: FieldParser<Key, T>
-    }>
-    keys: { [key: string]: KeyParser<T> } // $list -> true
-    any: KeyParser<T> // y.x
-  }
-  collect?: (args: Args<T>) => any
-  backtrack?: BackTrack<T>
-  requiresAsyncValidation?: (validationType: any) => Promise<boolean>
-  errorsCollector?: ErrorHandler<T>
-}
-
-export const walk = async <T>(
-  opts: Opts<T>,
-  value: any
-): Promise<{
-  target: T
-  errors: { code: ParseError; message: string }[]
-}> => {
-  const errors: { code: ParseError; message: string }[] = []
-
-  if (!('collect' in opts)) {
-    opts.collect = () => {}
-  }
-
-  if (!('backtrack' in opts)) {
-    opts.backtrack = (args, btC, c) => btC
-  }
-
-  if (!('requiresAsyncValidation' in opts)) {
-    opts.requiresAsyncValidation = async () => true
-  }
-
-  const errorsCollector: ErrorHandler<T> = (args, code) => {
-    const err = {
-      code,
-      message: `Error in ${args.path.join('.')}`,
-    }
-    if (opts.errorsCollector) {
-      opts.errorsCollector(args, code)
-    }
-    errors.push(err)
-  }
-
-  const parse: Parse<T> = async (prevArgs, key, value) => {
-    const collectedCommands: any[] = []
-    const fromBackTrack: any[] = []
-    const args: Args<T> = {
-      schema: opts.schema,
-      path: key ? [...prevArgs.path, key] : prevArgs.path,
-      key: key ?? prevArgs.path[prevArgs.path.length - 1],
-      parentValue: value ? prevArgs.value : undefined,
-      value: value ?? prevArgs.value,
-      target: prevArgs.target,
-      parse: prevArgs.parse,
-      collect: (args) => {
-        collectedCommands.push(opts.collect(args))
-      },
-      fromBackTrack,
-      backtrack: opts.backtrack,
-      error: errorsCollector,
-      requiresAsyncValidation: prevArgs.requiresAsyncValidation,
-    }
-    if (typeof args.value === 'object' && args.value !== null) {
-      const q: Promise<Args<T> | void>[] = []
-
-      if (args.typeSchema && !args.fieldSchema) {
-        // top level
-      }
-
-      if (args.fieldSchema) {
-        //
-      }
-
-      // first do key parsers
-
-      if (Array.isArray(args.value)) {
-        for (let i = 0; i < args.value.length; i++) {
-          const parser = opts.parsers.keys[i] || opts.parsers.any
-          const j = i
-          q.push(
-            (async () => {
-              const newArgs = await parser({
-                ...args,
-                value: args.value[j],
-                path: [...args.path, j],
-                key: j,
-              })
-              if (newArgs) {
-                return parse(newArgs)
-              }
-            })()
-          )
-        }
-      } else {
-        for (const key in args.value) {
-          const parser = opts.parsers.keys[key] || opts.parsers.any
-          q.push(
-            (async () => {
-              const newArgs = await parser({
-                ...args,
-                value: args.value[key],
-                path: [...args.path, key],
-                key,
-              })
-              if (newArgs) {
-                return parse(newArgs)
-              }
-            })()
-          )
-        }
-      }
-
-      await Promise.all(q)
-
-      if (fromBackTrack.length || collectedCommands.length) {
-        const x = args.backtrack(args, fromBackTrack, collectedCommands)
-        if (x) {
-          prevArgs.fromBackTrack?.push(x)
-        }
-      }
-    }
-  }
-  const args: Args<T> = await opts.init(<Args<T>>{
-    schema: opts.schema,
-    path: [],
-    value,
-    parse,
-    collect: opts.collect,
-    backtrack: opts.backtrack,
-    error: errorsCollector,
-    requiresAsyncValidation: opts.requiresAsyncValidation,
-  })
-
-  if (!args) {
-    return {
-      // TODO: temp
-      // @ts-ignore // for now
-      target: {},
-      errors,
-    }
-  }
-  await parse(args)
-  return {
-    target: args.target,
-    errors,
-  }
-}

package/test/setWalker.ts

@@ -1,494 +0,0 @@
-import test from 'ava'
-import { BasedSchema, setWalker } from '../src/index'
-
-const schema: BasedSchema = {
-  types: {
-    bla: {
-      prefix: 'bl',
-      fields: {
-        visits: {
-          type: 'cardinality',
-        },
-        blub: {
-          type: 'number',
-        },
-        flap: {
-          type: 'number',
-        },
-        snurpobject: {
-          type: 'object',
-          properties: {
-            x: {
-              type: 'string',
-            },
-          },
-        },
-        snurp: {
-          type: 'array',
-          values: {
-            type: 'object',
-            properties: {
-              x: {
-                type: 'array',
-                values: {
-                  type: 'number',
-                },
-              },
-            },
-          },
-        },
-        setje: {
-          type: 'set',
-          items: { type: 'number' },
-        },
-        specialArray: {
-          type: 'array',
-          values: {
-            type: 'string',
-          },
-        },
-        snurpArray: {
-          type: 'array',
-          values: {
-            type: 'number',
-          },
-        },
-        powerLevel: {
-          type: 'integer',
-        },
-        bla: {
-          type: 'boolean',
-        },
-        time: {
-          type: 'timestamp',
-        },
-        form: {
-          title: 'A registration form',
-          description: 'A simple form example.',
-          type: 'object',
-          required: ['firstName', 'lastName'],
-          properties: {
-            bla: {
-              type: 'references',
-            },
-            blab: {
-              type: 'references',
-            },
-            snurp: {
-              type: 'reference',
-            },
-            things: {
-              enum: ['yuzi', 'jux', 'mr tony', 9000],
-            },
-            blub: {
-              type: 'set',
-              items: { type: 'string' },
-            },
-            json: {
-              type: 'json',
-            },
-            firstName: {
-              type: 'string',
-              title: 'First name',
-              default: 'Chuck',
-            },
-            lastName: {
-              type: 'string',
-              title: 'Last name',
-            },
-            age: {
-              type: 'integer',
-              title: 'Age',
-            },
-            bio: {
-              type: 'string',
-              title: 'Bio',
-            },
-            password: {
-              type: 'string',
-              title: 'Password',
-              minLength: 3,
-            },
-            telephone: {
-              type: 'string',
-              title: 'Telephone',
-              minLength: 10,
-            },
-          },
-        },
-      },
-    },
-  },
-  $defs: {},
-  languages: ['en'],
-  root: {
-    fields: {},
-  },
-  prefixToTypeMapping: {
-    bl: 'bla',
-  },
-}
-
-test('collect correctly', async (t) => {
-  const results: { path: (string | number)[]; value: any }[] = []
-  const now = Date.now()
-  await setWalker(
-    schema,
-    {
-      $id: 'bl1',
-      visits: {
-        flap: true,
-        snurp: false,
-        ua: '123435',
-      },
-      blub: {
-        $increment: 1,
-      },
-      bla: false,
-      time: now,
-      setje: [1, 2, 3],
-      form: {
-        lastName: 'de beer',
-        bla: ['bl123', 'bl234'],
-        blab: { $add: ['bl456'] },
-        blub: ['x'],
-        json: { bla: 1, x: 2, y: 3 },
-        snurp: 'blx12',
-        things: 'mr tony',
-        password: 'mypassword!',
-      },
-      snurpArray: {
-        $assign: {
-          $idx: 0,
-          $value: 100,
-        },
-      },
-      specialArray: {
-        $insert: {
-          $value: ['a', 'b', 'c'],
-          $idx: 0,
-        },
-      },
-      snurp: [
-        {
-          x: [1, 2, 3],
-        },
-      ],
-    },
-    {
-      collectErrors: (info) => {
-        // fix fields (too heavy)
-      },
-      collect: ({ path, value, typeSchema, fieldSchema, target }) => {
-        results.push({
-          path,
-          value,
-        })
-      },
-      checkRequiredFields: async (path) => {
-        return true
-      },
-      referenceFilterCondition: async (id, filter) => {
-        return true
-      },
-    }
-  )
-
-  const result = [
-    { path: ['visits'], value: '3a9009740ee' },
-    { path: ['blub'], value: { $increment: 1 } },
-    { path: ['time'], value: now },
-    { path: ['form', 'snurp'], value: 'blx12' },
-    {
-      path: ['snurpArray', 0],
-      value: 100,
-    },
-    { path: ['bla'], value: false },
-    { path: ['form', 'lastName'], value: 'de beer' },
-    { path: ['form', 'json'], value: '{"bla":1,"x":2,"y":3}' },
-    { path: ['form', 'things'], value: 2 },
-    { path: ['form', 'password'], value: 'mypassword!' },
-    { path: ['form', 'bla'], value: { $value: ['bl123', 'bl234'] } },
-    { path: ['form', 'blab'], value: { $add: ['bl456'] } },
-    { path: ['setje'], value: { $value: [1, 2, 3] } },
-    { path: ['form', 'blub'], value: { $value: ['x'] } },
-    {
-      path: ['specialArray'],
-      value: { $insert: { $value: ['a', 'b', 'c'], $idx: 0 } },
-    },
-    { path: ['snurp'], value: { $delete: true } },
-    { path: ['snurp', 0, 'x'], value: { $delete: true } },
-    { path: ['snurp', 0, 'x', 0], value: 1 },
-    { path: ['snurp', 0, 'x', 1], value: 2 },
-    { path: ['snurp', 0, 'x', 2], value: 3 },
-  ]
-
-  t.deepEqual(results, result)
-
-  const results2: any[] = []
-  await setWalker(
-    schema,
-    {
-      $id: 'bl1',
-      blub: {
-        $value: 4,
-      },
-      flap: {
-        $default: 1,
-      },
-    },
-    {
-      collectErrors: (info) => {
-        // {
-        //   path,
-        //   value,
-        //   typeSchema,
-        //   fieldSchema,
-        //   target,
-        //   code,
-        //   message,
-        // }
-
-        console.error(info.message)
-        // fix fields (too heavy)
-      },
-      collect: ({ path, value, typeSchema, fieldSchema, target }) => {
-        results2.push({
-          path,
-          value,
-        })
-      },
-      checkRequiredFields: async (path) => {
-        return false
-      },
-      referenceFilterCondition: async (id, filter) => {
-        return true
-      },
-    }
-  )
-
-  t.deepEqual(results2, [
-    { path: ['blub'], value: { $value: 4 } },
-    { path: ['flap'], value: { $default: 1 } },
-  ])
-
-  const results3: any[] = []
-  await setWalker(
-    schema,
-    {
-      $id: 'bl1',
-      snurpArray: {
-        $push: 1,
-      },
-      specialArray: {
-        $push: { $value: 'flap' },
-      },
-    },
-    {
-      collectErrors: (info) => {
-        // {
-        //   path,
-        //   value,
-        //   typeSchema,
-        //   fieldSchema,
-        //   target,
-        //   code,
-        //   message,
-        // }
-
-        console.error(info.message)
-        // fix fields (too heavy)
-      },
-      collect: ({ path, value, typeSchema, fieldSchema, target }) => {
-        results3.push({
-          path,
-          value,
-        })
-      },
-      checkRequiredFields: async (path) => {
-        return false
-      },
-      referenceFilterCondition: async (id, filter) => {
-        return true
-      },
-    }
-  )
-
-  t.deepEqual(results3, [
-    { path: ['snurpArray'], value: { $push: [1] } },
-    { path: ['specialArray'], value: { $push: [{ $value: 'flap' }] } },
-  ])
-})
-
-test('required', async (t) => {
-  const schema: BasedSchema = {
-    types: {
-      bla: {
-        prefix: 'bl',
-        required: ['blub', 'flap', 'snurp'],
-        fields: {
-          blub: {
-            type: 'number',
-          },
-          flap: {
-            type: 'number',
-          },
-          snurp: {
-            type: 'object',
-            required: ['x'],
-            properties: {
-              x: {
-                type: 'object',
-                required: ['a', 'b', 'c'],
-                properties: {
-                  a: { type: 'string' },
-                  b: { type: 'string' },
-                  c: { type: 'string' },
-                },
-              },
-            },
-          },
-          array: {
-            type: 'array',
-            values: {
-              type: 'object',
-              required: ['a', 'b', 'c'],
-              properties: {
-                a: { type: 'string' },
-                b: { type: 'string' },
-                c: { type: 'string' },
-              },
-            },
-          },
-        },
-      },
-    },
-    $defs: {},
-    languages: ['en'],
-    root: {
-      fields: {},
-    },
-    prefixToTypeMapping: {
-      bl: 'bla',
-    },
-  }
-
-  const t1 = await setWalker(
-    schema,
-    {
-      type: 'bla',
-      blub: 1,
-      flap: 1,
-      snurp: {
-        x: { a: 'b' },
-      },
-    },
-    {
-      collectErrors: (info) => {
-        // {
-        //   path,
-        //   value,
-        //   typeSchema,
-        //   fieldSchema,
-        //   target,
-        //   code,
-        //   message,
-        // }
-
-        console.error(info.message)
-        // fix fields (too heavy)
-      },
-      collect: ({ path, value, typeSchema, fieldSchema, target }) => {},
-      checkRequiredFields: async (paths) => {
-        return true
-      },
-      referenceFilterCondition: async (id, filter) => {
-        return true
-      },
-    }
-  )
-
-  t.deepEqual(t1.required, [
-    ['snurp', 'x', 'b'],
-    ['snurp', 'x', 'c'],
-  ])
-
-  const t2 = await setWalker(
-    schema,
-    {
-      type: 'bla',
-      array: [
-        {
-          a: 'hello', // say cant set non existing field
-        },
-      ],
-    },
-    {
-      collectErrors: (info) => {
-        // {
-        //   path,
-        //   value,
-        //   typeSchema,
-        //   fieldSchema,
-        //   target,
-        //   code,
-        //   message,
-        // }
-
-        console.error(info.message)
-        // fix fields (too heavy)
-      },
-      collect: ({ path, value, typeSchema, fieldSchema, target }) => {},
-      checkRequiredFields: async (paths) => {
-        // should be [snurp.x.b, snurp.x.c]
-        return true
-      },
-      referenceFilterCondition: async (id, filter) => {
-        return true
-      },
-    }
-  )
-
-  t.deepEqual(t2.required, [
-    ['array', 0, 'b'],
-    ['array', 0, 'c'],
-    ['blub'],
-    ['flap'],
-    ['snurp'],
-  ])
-
-  t.true(true)
-})
-
-test.only('collect all errors', async (t) => {
-  try {
-    await setWalker(
-      schema,
-      {
-        type: 'bla',
-        blub: 'snux',
-        flap: 'gurt',
-        snurpobject: {
-          x: 1,
-        },
-        // wrong validate total objects
-        snurp: {
-          // checking non formatted objects
-          x: { a: 20220 },
-        },
-      },
-      {
-        checkRequiredFields: async (paths) => {
-          return true
-        },
-        referenceFilterCondition: async (id, filter) => {
-          return true
-        },
-      }
-    )
-  } catch (err) {
-    console.info(err)
-  }
-
-  t.true(true)
-})