@based/schema 2.0.0 → 2.2.0

package/test/number.ts

@@ -1,435 +0,0 @@
-import test from 'ava'
-import {
-  ArgsClass,
-  BasedSchema,
-  BasedSchemaCollectProps,
-  BasedSetTarget,
-  setWalker,
-} from '../src/index'
-import { ParseError } from '../src/error'
-import { resultCollect, errorCollect } from './utils'
-type NumberTypes = 'number' | 'timestamp' | 'integer'
-
-const schema: BasedSchema = {
-  types: {
-    bla: {
-      prefix: 'bl',
-      fields: {
-        number: {
-          type: 'number',
-          maximum: 6,
-          minimum: 3,
-        },
-        infiniteNum: {
-          type: 'number',
-        },
-        infiniteInt: {
-          type: 'integer',
-        },
-        exclusiveminmax: {
-          type: 'number',
-          minimum: 3,
-          exclusiveMinimum: true,
-          maximum: 6,
-          exclusiveMaximum: true,
-        },
-        integer: {
-          type: 'integer',
-        },
-        multipleOf: {
-          type: 'integer',
-          multipleOf: 3,
-        },
-        set: {
-          type: 'set',
-          items: { type: 'number', minimum: 3, maximum: 6 },
-        },
-      },
-    },
-  },
-  $defs: {},
-  language: 'en',
-  root: {
-    fields: {},
-  },
-  prefixToTypeMapping: {
-    bl: 'bla',
-  },
-}
-
-//todo need help typing this maybe
-
-test('min-max', async (t) => {
-  const e1 = await setWalker(schema, {
-    $id: 'bl1',
-    number: 1,
-  })
-
-  const e2 = await setWalker(schema, {
-    $id: 'bl1',
-    number: 10,
-  })
-
-  const res1 = await setWalker(schema, {
-    $id: 'bl1',
-    number: 3,
-  })
-
-  const res2 = await setWalker(schema, {
-    $id: 'bl1',
-    number: 6,
-  })
-
-  t.true(errorCollect(e1, e2).length > 0)
-
-  t.deepEqual(resultCollect(res1, res2), [
-    { path: ['number'], value: 3 },
-    { path: ['number'], value: 6 },
-  ])
-})
-
-test('min-max exclusive', async (t) => {
-  const e1 = await setWalker(schema, {
-    $id: 'bl1',
-    exclusiveminmax: 3,
-  })
-
-  const e2 = await setWalker(schema, {
-    $id: 'bl1',
-    exclusiveminmax: 6,
-  })
-
-  const res1 = await setWalker(schema, {
-    $id: 'bl1',
-    exclusiveminmax: 4,
-  })
-
-  const res2 = await setWalker(schema, {
-    $id: 'bl1',
-    exclusiveminmax: 5,
-  })
-
-  t.assert(errorCollect(e1, e2).length > 0)
-
-  t.deepEqual(resultCollect(res1, res2), [
-    { path: ['exclusiveminmax'], value: 4 },
-    { path: ['exclusiveminmax'], value: 5 },
-  ])
-})
-
-test('isInteger', async (t) => {
-  const e1 = await setWalker(schema, {
-    $id: 'bl1',
-    integer: 6.5,
-  })
-
-  const res1 = await setWalker(schema, {
-    $id: 'bl1',
-    integer: 5,
-  })
-
-  t.assert(errorCollect(e1).length > 0)
-  t.deepEqual(resultCollect(res1), [{ path: ['integer'], value: 5 }])
-})
-
-test('isMultiple', async (t) => {
-  const e1 = await setWalker(schema, {
-    $id: 'bl1',
-    multipleOf: 7,
-  })
-
-  const res1 = await setWalker(schema, {
-    $id: 'bl1',
-    multipleOf: 9,
-  })
-
-  t.assert(errorCollect(e1).length > 0)
-  t.deepEqual(resultCollect(res1), [{ path: ['multipleOf'], value: 9 }])
-})
-
-//TODO fix
-test('numbers in a set', async (t) => {
-  const e1 = await setWalker(schema, {
-    $id: 'bl1',
-    set: [9, 4, 5, 2],
-  })
-  const res1 = await setWalker(schema, { $id: 'bl1', set: [3, 3, 3, 3] })
-
-  t.assert(errorCollect(e1).length > 0)
-  t.deepEqual(resultCollect(res1), [
-    { path: ['set'], value: { $value: [3, 3, 3, 3] } },
-  ])
-})
-//TODO fix
-test('value', async (t) => {
-  const e1 = await setWalker(schema, {
-    $id: 'bl1',
-    number: { $value: 7 },
-  })
-  const e2 = await setWalker(schema, {
-    $id: 'bl1',
-    exclusiveminmax: { $value: 3 },
-  })
-  const e3 = await setWalker(schema, {
-    $id: 'bl1',
-    integer: { value: 3.5 },
-  })
-
-  const e4 = await setWalker(schema, {
-    $id: 'bl1',
-    set: { $value: [1, 3, 3, 4] },
-  })
-
-  const e5 = await setWalker(schema, {
-    $id: 'bl1',
-    multipleOf: { $value: 2 },
-  })
-
-  const res1 = await setWalker(schema, {
-    $id: 'bl1',
-    number: { $value: 4 },
-  })
-  const res2 = await setWalker(schema, {
-    $id: 'bl1',
-    integer: { $value: 4 },
-  })
-  const res3 = await setWalker(schema, {
-    $id: 'bl1',
-    exclusiveminmax: { $value: 4 },
-  })
-  const res4 = await setWalker(schema, {
-    $id: 'bl1',
-    multipleOf: { $value: 6 },
-  })
-
-  const res5 = await setWalker(schema, {
-    $id: 'bl1',
-    set: { $value: [3, 3, 3, 4] },
-  })
-
-  t.assert(errorCollect(e1, e2, e3, e4, e5).length > 0)
-  t.deepEqual(resultCollect(res1, res2, res3, res4), [
-    { path: ['number'], value: 4 },
-    { path: ['integer'], value: 4 },
-    { path: ['exclusiveminmax'], value: 4 },
-    { path: ['multipleOf'], value: 6 },
-  ])
-})
-
-test('default', async (t) => {
-  const e1 = await setWalker(schema, {
-    $id: 'bl1',
-    number: { $default: 7 },
-  })
-  const e2 = await setWalker(schema, {
-    $id: 'bl1',
-    exclusiveminmax: { $default: 3 },
-  })
-  const e3 = await setWalker(schema, {
-    $id: 'bl1',
-    integer: { default: 3.5 },
-  })
-
-  const e4 = await setWalker(schema, {
-    $id: 'bl1',
-    set: { $default: [1, 3, 3, 4] },
-  })
-
-  const e5 = await setWalker(schema, {
-    $id: 'bl1',
-    multipleOf: { $default: 2 },
-  })
-
-  const res1 = await setWalker(schema, {
-    $id: 'bl1',
-    number: { $default: 4 },
-  })
-  const res2 = await setWalker(schema, {
-    $id: 'bl1',
-    integer: { $default: 4 },
-  })
-  const res3 = await setWalker(schema, {
-    $id: 'bl1',
-    exclusiveminmax: { $default: 4 },
-  })
-  const res4 = await setWalker(schema, {
-    $id: 'bl1',
-    multipleOf: { $default: 6 },
-  })
-
-  const res5 = await setWalker(schema, {
-    $id: 'bl1',
-    set: { $default: [3, 3, 3, 4] },
-  })
-
-  t.assert(errorCollect(e1, e2, e3, e4, e5).length > 0)
-  t.deepEqual(resultCollect(res1, res2, res3, res4, res5), [
-    { path: ['number'], value: { $default: 4 } },
-    { path: ['integer'], value: { $default: 4 } },
-    { path: ['exclusiveminmax'], value: { $default: 4 } },
-    { path: ['multipleOf'], value: { $default: 6 } },
-    { path: ['set'], value: { $default: { $value: [3, 3, 3, 4] } } },
-  ])
-})
-
-test('decrement', async (t) => {
-  //maxmin
-  const e1 = await setWalker(schema, {
-    $id: 'bl1',
-    number: { $decrement: 2 },
-  })
-  const e2 = await setWalker(schema, {
-    $id: 'bl1',
-    number: { $decrement: 7 },
-  })
-
-  const res1 = await setWalker(schema, {
-    $id: 'bl1',
-    number: { $decrement: 3 },
-  })
-  //exclusiveminmax
-  const e3 = await setWalker(schema, {
-    $id: 'bl1',
-    exclusiveminmax: { $decrement: 3 },
-  })
-  const e4 = await setWalker(schema, {
-    $id: 'bl1',
-    exclusiveminmax: { $decrement: 6 },
-  })
-
-  const res2 = await setWalker(schema, {
-    $id: 'bl1',
-    exclusiveminmax: { $decrement: 4 },
-  })
-
-  //integer
-  const e5 = await setWalker(schema, {
-    $id: 'bl1',
-    integer: { $decrement: 3.5 },
-  })
-
-  const res3 = await setWalker(schema, {
-    $id: 'bl1',
-    integer: { $decrement: 3 },
-  })
-  //multiple of
-
-  const e6 = await setWalker(schema, {
-    $id: 'bl1',
-    multipleOf: { $decrement: 7 },
-  })
-
-  const res4 = await setWalker(schema, {
-    $id: 'bl1',
-    multipleOf: { $decrement: 9 },
-  })
-
-  t.assert(errorCollect(e1, e2, e3, e4, e5, e6).length > 0)
-  t.deepEqual(resultCollect(res1, res2, res3, res4), [
-    { path: ['number'], value: { $decrement: 3 } },
-    { path: ['exclusiveminmax'], value: { $decrement: 4 } },
-    { path: ['integer'], value: { $decrement: 3 } },
-    { path: ['multipleOf'], value: { $decrement: 9 } },
-  ])
-})
-
-test('increment', async (t) => {
-  //maxmin
-  const e1 = await setWalker(schema, {
-    $id: 'bl1',
-    number: { $increment: 2 },
-  })
-  const e2 = await setWalker(schema, {
-    $id: 'bl1',
-    number: { $increment: 7 },
-  })
-
-  const res1 = await setWalker(schema, {
-    $id: 'bl1',
-    number: { $increment: 3 },
-  })
-  //exclusiveminmax
-  const e3 = await setWalker(schema, {
-    $id: 'bl1',
-    exclusiveminmax: { $increment: 3 },
-  })
-  const e4 = await setWalker(schema, {
-    $id: 'bl1',
-    exclusiveminmax: { $increment: 6 },
-  })
-
-  const res2 = await setWalker(schema, {
-    $id: 'bl1',
-    exclusiveminmax: { $increment: 4 },
-  })
-
-  //integer
-  const e5 = await setWalker(schema, {
-    $id: 'bl1',
-    integer: { $increment: 3.5 },
-  })
-
-  const res3 = await setWalker(schema, {
-    $id: 'bl1',
-    integer: { $increment: 3 },
-  })
-  //multiple of
-
-  const e6 = await setWalker(schema, {
-    $id: 'bl1',
-    multipleOf: { $increment: 7 },
-  })
-
-  const res4 = await setWalker(schema, {
-    $id: 'bl1',
-    multipleOf: { $increment: 9 },
-  })
-
-  t.assert(errorCollect(e1, e2, e3, e4, e5, e6).length > 0)
-  t.deepEqual(resultCollect(res1, res2, res3, res4), [
-    { path: ['number'], value: { $increment: 3 } },
-    { path: ['exclusiveminmax'], value: { $increment: 4 } },
-    { path: ['integer'], value: { $increment: 3 } },
-    { path: ['multipleOf'], value: { $increment: 9 } },
-  ])
-})
-
-test('NaN', async (t) => {
-  const r = await setWalker(schema, {
-    $id: 'bl120',
-    integer: NaN,
-  })
-  t.is(r.errors.length, 1)
-})
-
-test('Infinity (integer)', async (t) => {
-  const r = await setWalker(schema, {
-    $id: 'bl120',
-    integer: Infinity,
-  })
-  t.is(r.errors.length, 1)
-})
-
-test('Infinity (number)', async (t) => {
-  const r = await setWalker(schema, {
-    $id: 'bl120',
-    infiniteNum: Infinity,
-  })
-  t.is(r.errors.length, 1)
-})
-
-test('number -infinity', async (t) => {
-  const r = await setWalker(schema, {
-    $id: 'bl120',
-    infiniteNum: -Infinity,
-  })
-  t.is(r.errors.length, 1)
-})
-
-test('number with max infinity', async (t) => {
-  const r = await setWalker(schema, {
-    $id: 'bl120',
-    number: Infinity,
-  })
-  t.is(r.errors.length, 1)
-})

package/test/reference.ts

@@ -1,219 +0,0 @@
-import test from 'ava'
-import { BasedSchema, setWalker } from '../src/index'
-import { resultCollect } from './utils'
-
-const schema: BasedSchema = {
-  types: {
-    thing: {
-      prefix: 'ti',
-      fields: {
-        priority: { type: 'number' },
-        something: { type: 'string', format: 'strongPassword' },
-      },
-    },
-    bla: {
-      prefix: 'bl',
-      fields: {
-        ref: {
-          type: 'reference',
-        },
-        children: {
-          type: 'references',
-        },
-        referencesToThings: {
-          type: 'references',
-          allowedTypes: ['thing'],
-        },
-        referenceToThing: {
-          type: 'reference',
-          allowedTypes: ['thing'],
-        },
-      },
-    },
-  },
-  $defs: {},
-  language: 'en',
-  translations: ['de', 'nl', 'ro', 'za', 'ae'],
-  root: {
-    fields: {},
-  },
-  prefixToTypeMapping: {
-    bl: 'bla',
-    ti: 'thing',
-  },
-}
-
-let r
-
-test('simple error', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    referenceToThing: 'sdfefewfewfewewffwe',
-  })
-
-  t.true(r.errors.length === 1)
-})
-
-test('simple case ', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    referenceToThing: 'tibla',
-  })
-
-  t.deepEqual(resultCollect(r), [
-    { path: ['referenceToThing'], value: 'tibla' },
-  ])
-})
-
-test('reference to wrong type', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    referenceToThing: 'blbla',
-  })
-  t.true(r.errors.length === 1)
-})
-
-test('references with wrongly formatted ids and incorrect types ', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    referencesToThings: ['blbla', 'ti123', 'ewiohfdoweihfw'],
-  })
-
-  t.true(r.errors.length === 2)
-})
-
-test('references to empty array (clear)', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    referencesToThings: [],
-  })
-  t.deepEqual(resultCollect(r), [
-    { path: ['referencesToThings'], value: { $value: [] } },
-  ])
-  t.is(r.errors.length, 0)
-})
-
-test('$remove references', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    referencesToThings: { $remove: ['ti123'] },
-  })
-
-  t.deepEqual(resultCollect(r), [
-    { path: ['referencesToThings'], value: { $remove: ['ti123'] } },
-  ])
-})
-
-test('$add 0 2 wrong', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    referencesToThings: { $add: ['blbla', 'ti123', 'ewiohfdoweihfw'] },
-  })
-
-  t.true(r.errors.length === 2)
-})
-
-test('$add correct ', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    referencesToThings: { $add: 'ti123' },
-  })
-
-  t.deepEqual(resultCollect(r), [
-    { path: ['referencesToThings'], value: { $add: ['ti123'] } },
-  ])
-})
-
-test('$remove $value not allowed', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    referencesToThings: { $remove: { $value: 'ti123' } },
-  })
-
-  t.true(r.errors.length > 0)
-})
-
-test('reference to an object', async (t) => {
-  r = await setWalker(
-    schema,
-    {
-      $id: 'bl120',
-      referenceToThing: {
-        type: 'thing',
-        priority: 9000,
-      },
-    },
-    async (args) => {
-      if (args.value.type === 'thing') {
-        return 'tilil'
-      } else {
-        return 'bl1221'
-      }
-    }
-  )
-
-  t.is(r.errors.length, 0)
-
-  t.deepEqual(resultCollect(r), [
-    { path: ['referenceToThing'], value: 'tilil' },
-  ])
-
-  t.true(true)
-})
-
-test('nested references + $add (deep)', async (t) => {
-  r = await setWalker(
-    schema,
-    {
-      $id: 'bl1221',
-      children: {
-        $add: [
-          {
-            type: 'bla',
-          },
-        ],
-      },
-    },
-    async (args) => {
-      if (args.value.type === 'thing') {
-        return 'tilil'
-      } else {
-        return 'bl1221'
-      }
-    }
-  )
-  t.is(r.errors.length, 0)
-  t.deepEqual(resultCollect(r), [
-    { path: ['children'], value: { $add: ['bl1221'] } },
-  ])
-})
-
-test('nested ref + references', async (t) => {
-  r = await setWalker(
-    schema,
-    {
-      $id: 'bl1221',
-      ref: {
-        $id: 'bl1221',
-      },
-      children: [
-        {
-          $id: 'bl1221',
-        },
-      ],
-    },
-    async (args) => {
-      if (args.value.type === 'thing') {
-        return 'tilil'
-      } else {
-        return 'bl1221'
-      }
-    }
-  )
-  t.is(r.errors.length, 0)
-
-  t.deepEqual(resultCollect(r), [
-    { path: ['ref'], value: 'bl1221' },
-    { path: ['children'], value: { $value: ['bl1221'] } },
-  ])
-})