@based/schema 1.3.2 → 2.1.0

package/test/text.ts

@@ -1,342 +0,0 @@
-import { setWalker, BasedSchema } from '../src'
-import test from 'ava'
-import { ParseError } from '../src/error'
-import { resultCollect } from './utils'
-
-const schema: BasedSchema = {
-  types: {
-    thing: {
-      prefix: 'ti',
-      fields: {
-        something: { type: 'string', format: 'strongPassword' },
-      },
-    },
-    bla: {
-      prefix: 'bl',
-      fields: {
-        text: {
-          type: 'text',
-          pattern: '[^xz]{1,10}',
-        },
-      },
-    },
-  },
-  $defs: {},
-  languages: ['en', 'de', 'nl', 'ro', 'za', 'ae'],
-  root: {
-    fields: {},
-  },
-  prefixToTypeMapping: {
-    bl: 'bla',
-    ti: 'thing',
-  },
-}
-
-let r
-
-test('throw error no language', async (t) => {
-  let r = await setWalker(schema, {
-    $id: 'bl120',
-    text: { $value: 'x' },
-  })
-  t.true(r.errors.length > 0)
-})
-
-test('simple case', async (t) => {
-  let r = await setWalker(schema, {
-    $id: 'bl120',
-    text: { en: 'flap' },
-  })
-  t.deepEqual(resultCollect(r), [
-    { path: ['text', 'en'], value: 'flap' },
-    { path: ['text'], value: { en: 'flap' } },
-  ])
-})
-
-test('simple case $value', async (t) => {
-  let r = await setWalker(schema, {
-    $id: 'bl120',
-    text: { en: { $value: 'flap' } },
-  })
-  t.deepEqual(resultCollect(r), [
-    { path: ['text', 'en'], value: 'flap' },
-    { path: ['text'], value: { en: { $value: 'flap' } } },
-  ])
-})
-
-test('simple case $language', async (t) => {
-  let r = await setWalker(schema, {
-    $id: 'bl120',
-    $language: 'en',
-    text: 'flap',
-  })
-  t.deepEqual(resultCollect(r), [
-    { path: ['text', 'en'], value: 'flap' },
-    { path: ['text'], value: { en: 'flap' } },
-  ])
-})
-
-test('simple case with value', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    $language: 'za',
-    text: { $value: 'flap' },
-  })
-  t.deepEqual(resultCollect(r), [
-    { path: ['text', 'za'], value: 'flap' },
-    { path: ['text'], value: { $value: 'flap' } },
-  ])
-})
-
-test('simple case $value /w obj', async (t) => {
-  let r = await setWalker(schema, {
-    $id: 'bl120',
-    text: { $value: { en: 'flap' } },
-  })
-  t.deepEqual(resultCollect(r), [
-    { path: ['text', 'en'], value: 'flap' },
-    { path: ['text'], value: { $value: { en: 'flap' } } },
-  ])
-})
-
-test('text default', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    $language: 'za',
-    text: { $default: 'sdsdds' },
-  })
-  t.deepEqual(resultCollect(r), [
-    { path: ['text', 'za'], value: { $default: 'sdsdds' } },
-    { path: ['text'], value: { $default: 'sdsdds' } },
-  ])
-})
-
-test('default and lang:default', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    $language: 'za',
-    text: { $default: 'sdsdds', en: { $default: 'flapflap' } },
-  })
-
-  t.deepEqual(resultCollect(r), [
-    { path: ['text', 'za'], value: { $default: 'sdsdds' } },
-    { path: ['text', 'en'], value: { $default: 'flapflap' } },
-    {
-      path: ['text'],
-      value: { $default: 'sdsdds', en: { $default: 'flapflap' } },
-    },
-  ])
-})
-
-test('default: lang, lang', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    $language: 'za',
-    text: { $default: { de: 'dsnfds' }, en: { $default: 'flapflap' } },
-  })
-  t.deepEqual(resultCollect(r), [
-    { path: ['text', 'de'], value: { $default: 'dsnfds' } },
-    { path: ['text', 'en'], value: { $default: 'flapflap' } },
-    {
-      path: ['text'],
-      value: { $default: { de: 'dsnfds' }, en: { $default: 'flapflap' } },
-    },
-  ])
-})
-
-test('defaullt:lang, lang, lang:default', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    $language: 'za',
-    text: {
-      $default: { de: 'dsnfds' },
-      nl: 'flapperonus',
-      en: { $default: 'flapflap' },
-    },
-  })
-  t.deepEqual(resultCollect(r), [
-    { path: ['text', 'de'], value: { $default: 'dsnfds' } },
-    { path: ['text', 'nl'], value: 'flapperonus' },
-    { path: ['text', 'en'], value: { $default: 'flapflap' } },
-    {
-      path: ['text'],
-      value: {
-        $default: { de: 'dsnfds' },
-        nl: 'flapperonus',
-        en: { $default: 'flapflap' },
-      },
-    },
-  ])
-})
-
-test('default:lang, lang, lang:value, lang:default', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    $language: 'za',
-    text: {
-      $default: { de: 'dsnfds' },
-      nl: 'flapperonus',
-      ro: { $value: 'durp' },
-      en: { $default: 'flapflap' },
-    },
-  })
-
-  t.deepEqual(resultCollect(r), [
-    { path: ['text', 'de'], value: { $default: 'dsnfds' } },
-    { path: ['text', 'nl'], value: 'flapperonus' },
-    { path: ['text', 'ro'], value: 'durp' },
-    { path: ['text', 'en'], value: { $default: 'flapflap' } },
-    {
-      path: ['text'],
-      value: {
-        $default: { de: 'dsnfds' },
-        nl: 'flapperonus',
-        ro: { $value: 'durp' },
-        en: { $default: 'flapflap' },
-      },
-    },
-  ])
-})
-
-test('value:lang, lang, default:lang, lang:value, lang:default', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    $language: 'za',
-    text: {
-      $value: 'durp',
-      nl: 'flapperonus',
-      $default: {
-        ae: 'habibi',
-      },
-      ro: { $value: 'durp' },
-      en: { $default: 'flapflap' },
-    },
-  })
-
-  t.deepEqual(resultCollect(r), [
-    { path: ['text', 'za'], value: 'durp' },
-    { path: ['text', 'nl'], value: 'flapperonus' },
-    { path: ['text', 'ae'], value: { $default: 'habibi' } },
-    { path: ['text', 'ro'], value: 'durp' },
-    { path: ['text', 'en'], value: { $default: 'flapflap' } },
-    {
-      path: ['text'],
-      value: {
-        $value: 'durp',
-        nl: 'flapperonus',
-        $default: {
-          ae: 'habibi',
-        },
-        ro: { $value: 'durp' },
-        en: { $default: 'flapflap' },
-      },
-    },
-  ])
-})
-
-test('value: wrong pattern, lang, default:lang, lang:value, lang:default', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    $language: 'za',
-    text: {
-      $value: 'xz',
-      nl: 'flapperonus',
-      $default: {
-        ae: 'habibi',
-      },
-      ro: { $value: 'durp' },
-      en: { $default: 'xzxz' },
-    },
-  })
-  t.true(r.errors.length > 0)
-})
-
-test('text delete', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    text: {
-      $delete: true,
-    },
-  })
-  t.deepEqual(resultCollect(r), [{ path: ['text'], value: { $delete: true } }])
-})
-
-test('text delete single language', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    text: {
-      en: {
-        $delete: true,
-      },
-    },
-  })
-  t.deepEqual(resultCollect(r), [
-    { path: ['text', 'en'], value: { $delete: true } },
-    {
-      path: ['text'],
-      value: {
-        en: {
-          $delete: true,
-        },
-      },
-    },
-  ])
-})
-
-test('just delete', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    $delete: true,
-  })
-  t.true(r.errors.length === 1)
-})
-
-test('$default in collected path', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    text: {
-      en: {
-        $default: 'title',
-      },
-    },
-  })
-  t.is(r.errors.length, 0)
-  t.deepEqual(resultCollect(r), [
-    { path: ['text', 'en'], value: { $default: 'title' } },
-    {
-      path: ['text'],
-      value: {
-        en: {
-          $default: 'title',
-        },
-      },
-    },
-  ])
-})
-
-test('$default in collected path + $merge:false', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    text: {
-      $merge: false,
-      en: {
-        $default: 'title',
-      },
-    },
-  })
-  t.is(r.errors.length, 0)
-  t.deepEqual(resultCollect(r), [
-    { path: ['text'], value: { $delete: true } },
-
-    { path: ['text', 'en'], value: { $default: 'title' } },
-    {
-      path: ['text'],
-      value: {
-        $merge: false,
-        en: {
-          $default: 'title',
-        },
-      },
-    },
-  ])
-})

package/test/utils/index.ts

@@ -1,23 +0,0 @@
-import { Path } from '@saulx/utils'
-import { BasedSetTarget } from '../../src'
-import { ParseError } from '../../src/error'
-
-export const resultCollect = (...results: BasedSetTarget[]) => {
-  const assertableResults: { path: Path; value: any }[] = []
-  for (let i = 0; i < results.length; i++) {
-    assertableResults.push(
-      ...results[i].collected.map((v) => ({ path: v.path, value: v.value }))
-    )
-  }
-  return assertableResults
-}
-
-export const errorCollect = (...results: BasedSetTarget[]) => {
-  const errors: { path: Path; code: ParseError }[] = []
-  for (let i = 0; i < results.length; i++) {
-    if (results[i].errors) {
-      errors.push(...results[i].errors)
-    }
-  }
-  return errors
-}

package/test/validateSchema.ts

@@ -1,41 +0,0 @@
-import test from 'ava'
-import { validateSchema } from '../src/index'
-
-test.serial('throw on invalid schema', async (t) => {
-  const prefixError = t.throws(() => {
-    validateSchema({
-      $defs: {
-        yuzi: {
-          type: 'string',
-          title: 'BLA',
-          description: 'SNURP',
-        },
-      },
-      types: {
-        bla: {
-          prefix: 'fix',
-          fields: {
-            yuzi: {
-              type: 'object',
-              customValidator: async (value, path, target) => {
-                return true
-              },
-              properties: {
-                gurt: {
-                  $ref: '/$defs/yuzi',
-                },
-                flap: {
-                  enum: ['bla', 'blap', 'flip'],
-                },
-              },
-            },
-          },
-        },
-      },
-    })
-  })
-  t.is(
-    prefixError.message,
-    'Incorrect prefix "fix" for type "bla" has to be a string of 2 alphanumerical characters e.g. "Az", "ab", "cc", "10"'
-  )
-})

package/test/walker.ts

@@ -1,318 +0,0 @@
-import test from 'ava'
-import { BasedSchema, setWalker, walk } from '../src/index'
-import { wait } from '@saulx/utils'
-
-const schema: BasedSchema = {
-  types: {
-    thing: {
-      prefix: 'ti',
-      fields: {
-        priority: { type: 'number' },
-        something: { type: 'string', format: 'strongPassword' },
-      },
-    },
-    bla: {
-      prefix: 'bl',
-      fields: {
-        referencesToThings: {
-          type: 'references',
-          allowedTypes: ['thing'],
-        },
-        referenceToThing: {
-          type: 'reference',
-          allowedTypes: ['thing'],
-        },
-        enum: {
-          enum: ['tony', 'jim'],
-        },
-        exclusiveminmax: {
-          type: 'number',
-          minimum: 3,
-          exclusiveMinimum: true,
-          maximum: 6,
-          exclusiveMaximum: true,
-        },
-        text: {
-          type: 'text',
-          pattern: '[^xz]{1,10}',
-        },
-        timestamp: {
-          type: 'timestamp',
-        },
-        setOfNumbers: {
-          type: 'set',
-          items: {
-            type: 'number',
-          },
-        },
-        intarray: {
-          type: 'array',
-          values: {
-            type: 'integer',
-          },
-        },
-        object: {
-          type: 'object',
-          properties: {
-            flap: { type: 'boolean' },
-          },
-        },
-        name: {
-          minLength: 3,
-          maxLength: 6,
-          type: 'string',
-        },
-        phonkName: {
-          type: 'string',
-          pattern: '\\${1,4}',
-        },
-        flap: {
-          type: 'boolean',
-        },
-        x: {
-          type: 'object',
-          properties: {
-            flap: {
-              type: 'boolean',
-            },
-          },
-        },
-        record: {
-          type: 'record',
-          values: {
-            type: 'object',
-            properties: {
-              bla: {
-                type: 'array',
-                values: {
-                  type: 'object',
-                  properties: {
-                    snux: {
-                      type: 'object',
-                      properties: {
-                        x: {
-                          type: 'number',
-                        },
-                      },
-                    },
-                    flap: { type: 'number' },
-                  },
-                },
-              },
-            },
-          },
-        },
-        bla: {
-          type: 'set',
-          items: { type: 'string', minLength: 3, maxLength: 6 },
-        },
-      },
-    },
-  },
-  $defs: {},
-  languages: ['en', 'de', 'nl', 'ro', 'za', 'ae'],
-  root: {
-    fields: {},
-  },
-  prefixToTypeMapping: {
-    bl: 'bla',
-    ti: 'thing',
-  },
-}
-
-test('backtracking', async (t) => {
-  const results: any[] = []
-
-  const setObj = {
-    x: {
-      y: {
-        a: 10,
-        bla: [1, 2, 3, 4, 5],
-      },
-      c: 40,
-    },
-  }
-
-  await walk<{ lullz: true }>(
-    schema,
-    {
-      init: async () => {
-        return { target: { lullz: true } }
-      },
-      parsers: {
-        keys: {},
-        fields: {},
-        any: async (args) => {
-          args.collect()
-          return args
-        },
-      },
-      collect: (args) => {
-        return args.path.join('.')
-      },
-      backtrack: (args, fromBt, collected) => {
-        results.push({ path: args.path, bt: [...fromBt] })
-        return fromBt.length ? fromBt : collected
-      },
-    },
-    setObj
-  )
-
-  t.deepEqual(results, [
-    { path: ['x', 'y', 'bla'], bt: [] },
-    {
-      path: ['x', 'y'],
-      bt: [['x.y.bla.0', 'x.y.bla.1', 'x.y.bla.2', 'x.y.bla.3', 'x.y.bla.4']],
-    },
-    {
-      path: ['x'],
-      bt: [[['x.y.bla.0', 'x.y.bla.1', 'x.y.bla.2', 'x.y.bla.3', 'x.y.bla.4']]],
-    },
-    {
-      path: [],
-      bt: [
-        [[['x.y.bla.0', 'x.y.bla.1', 'x.y.bla.2', 'x.y.bla.3', 'x.y.bla.4']]],
-      ],
-    },
-  ])
-
-  const results2: any[] = []
-
-  await walk<{ lullz: true }>(
-    schema,
-    {
-      init: async () => {
-        return { target: { lullz: true } }
-      },
-      parsers: {
-        keys: {},
-        fields: {},
-        any: async (args) => {
-          args.collect()
-          return { target: { lullz: true } }
-        },
-      },
-      collect: (args) => {
-        return args.path.join('.')
-      },
-      backtrack: (args, fromBt, collected) => {
-        results2.push({ path: args.path, bt: [...fromBt] })
-        return fromBt.length ? fromBt : collected
-      },
-    },
-    setObj
-  )
-
-  t.deepEqual(results, results2)
-
-  const results3: any[] = []
-
-  let cnt = 0
-  await walk<{ lullz: true }>(
-    schema,
-    {
-      init: async () => {
-        return { target: { lullz: true } }
-      },
-      parsers: {
-        keys: {},
-        fields: {},
-        any: async (args) => {
-          cnt++
-          args.collect()
-          return cnt % 2 ? args : { target: { lullz: true } }
-        },
-      },
-      collect: (args) => {
-        return args.path.join('.')
-      },
-      backtrack: (args, fromBt, collected) => {
-        results3.push({ path: args.path, bt: [...fromBt] })
-        return fromBt.length ? fromBt : collected
-      },
-    },
-    setObj
-  )
-
-  t.deepEqual(results, results3)
-})
-
-test.only('parseTop update target', async (t) => {
-  const parsed: { path: (number | string)[]; target: any }[] = []
-  await walk<any>(
-    schema,
-    {
-      init: async () => {
-        return { target: { path: [] } }
-      },
-      parsers: {
-        keys: {},
-        fields: {},
-        any: async (args) => {
-          args.collect()
-          if (args.prev.key !== args.key) {
-            return {
-              parseTopLevel: true,
-              target: {
-                path: args.path.join('.'),
-                prevTarget: args.target.id,
-                id: args.id,
-              },
-              value: args.value,
-            }
-          }
-        },
-      },
-      collect: (args) => {
-        parsed.push({ path: args.path, target: args.target })
-        return args.path.join('.')
-      },
-    },
-    {
-      x: {
-        y: {
-          z: 'bla!',
-        },
-      },
-    }
-  )
-
-  t.deepEqual(parsed, [
-    { path: ['x'], target: { path: [] } },
-    {
-      path: ['x'],
-      target: { path: 'x', prevTarget: undefined, id: 2 },
-    },
-    {
-      path: ['x', 'y'],
-      target: { path: 'x', prevTarget: undefined, id: 2 },
-    },
-    { path: ['x', 'y'], target: { path: 'x.y', prevTarget: 2, id: 4 } },
-    {
-      path: ['x', 'y', 'z'],
-      target: { path: 'x.y', prevTarget: 2, id: 4 },
-    },
-    {
-      path: ['x', 'y', 'z'],
-      target: { path: 'x.y.z', prevTarget: 4, id: 6 },
-    },
-  ])
-})
-
-test.serial('perf setWalker', async (t) => {
-  let d = Date.now()
-  let collected = 0
-  let errs = 0
-  for (let i = 0; i < 1e5; i++) {
-    const x = await setWalker(schema, {
-      $id: 'bl120',
-      name: 'blasdsdsd',
-      x: { flap: true },
-    })
-    errs += x.errors.length
-    collected += x.collected.length
-  }
-  d = Date.now() - d
-  console.info('setting 200k', d, 'ms')
-  t.true(d < 1e3)
-})