@based/schema 2.0.0 → 2.2.0

package/test/rest.ts

@@ -1,185 +0,0 @@
-import test from 'ava'
-import { BasedSchema, setWalker } from '../src/index'
-import { errorCollect, resultCollect } from './utils'
-
-const schema: BasedSchema = {
-  types: {
-    thing: {
-      prefix: 'ti',
-      fields: {
-        priority: { type: 'number' },
-        something: { type: 'string', format: 'strongPassword' },
-      },
-    },
-    bla: {
-      prefix: 'bl',
-      fields: {
-        enum: {
-          enum: ['tony', 'jim'],
-        },
-        setOfNumbers: {
-          type: 'set',
-          items: {
-            type: 'number',
-          },
-        },
-        object: {
-          type: 'object',
-          properties: {
-            flap: { type: 'boolean' },
-          },
-        },
-        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: {},
-  language: 'en',
-  translations: ['de', 'nl', 'ro', 'za', 'ae'],
-  root: {
-    fields: {},
-  },
-  prefixToTypeMapping: {
-    bl: 'bla',
-    ti: 'thing',
-  },
-}
-
-let r
-
-test('enum simple', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    enum: 'tony',
-  })
-
-  t.true(r.errors.length === 0)
-  t.deepEqual(resultCollect(r), [{ path: ['enum'], value: 0 }])
-})
-
-test('enum not exist error', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    enum: 'kyle',
-  })
-  t.true(r.errors.length === 1)
-})
-
-test('default enum', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    enum: { $default: 'tony' },
-  })
-  t.true(r.errors.length === 0)
-  t.deepEqual(resultCollect(r), [{ path: ['enum'], value: { $default: 0 } }])
-})
-
-test('value enum ', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    enum: { $value: 'tony' },
-  })
-
-  t.true(r.errors.length === 0)
-  t.deepEqual(resultCollect(r), [{ path: ['enum'], value: 0 }])
-})
-
-test('value &  default enum ', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    enum: { $default: 'jim', $value: 'tony' },
-  })
-
-  t.true(r.errors.length === 2)
-})
-
-test('$value & $default enum ', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    enum: { $value: { $default: 'tony' } },
-  })
-  t.true(r.errors.length === 0)
-  t.deepEqual(resultCollect(r), [{ path: ['enum'], value: { $default: 0 } }])
-})
-
-test('default: value enum ', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    enum: { $default: { $value: 'tony' } },
-  })
-  t.true(r.errors.length === 0)
-  t.deepEqual(resultCollect(r), [{ path: ['enum'], value: { $default: 0 } }])
-})
-
-// ask about alias
-test('$alias ', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    $alias: 'bla',
-  })
-
-  t.true(r.errors.length === 0)
-})
-
-test('$alias array', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    $alias: ['bla'],
-  })
-
-  t.true(r.errors.length === 0)
-})
-
-test('object: boolean', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    object: {
-      flap: true,
-    },
-  })
-
-  t.true(r.errors.length === 0)
-  t.deepEqual(resultCollect(r), [
-    { path: ['object', 'flap'], value: true },
-    { path: ['object'], value: { flap: true } },
-  ])
-})

package/test/set.ts

@@ -1,104 +0,0 @@
-import test from 'ava'
-import { BasedSchema, setWalker, walk } from '../src/index'
-import { wait } from '@saulx/utils'
-import { resultCollect } from './utils'
-let r
-const schema: BasedSchema = {
-  types: {
-    thing: {
-      prefix: 'ti',
-      fields: {
-        something: { type: 'string', format: 'strongPassword' },
-      },
-    },
-    bla: {
-      prefix: 'bl',
-      fields: {
-        x: {
-          type: 'object',
-          properties: {
-            bla: { type: 'string' },
-          },
-        },
-        setOfNumbers: {
-          type: 'set',
-          items: {
-            type: 'number',
-          },
-        },
-        bla: {
-          type: 'set',
-          items: { type: 'string', minLength: 3, maxLength: 6 },
-        },
-      },
-    },
-  },
-  $defs: {},
-  language: 'en',
-  translations: ['de', 'nl', 'ro', 'za', 'ae'],
-  root: {
-    fields: {},
-  },
-  prefixToTypeMapping: {
-    bl: 'bla',
-    ti: 'thing',
-  },
-}
-
-test('simple setNum', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    setOfNumbers: [1, 2, 3, 4, 5],
-  })
-
-  t.true(r.errors.length === 0)
-  t.deepEqual(resultCollect(r), [
-    { path: ['setOfNumbers'], value: { $value: [1, 2, 3, 4, 5] } },
-  ])
-})
-
-test('default arr', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    setOfNumbers: { $add: 20 },
-  })
-
-  t.true(r.errors.length === 0)
-  t.deepEqual(resultCollect(r), [
-    { path: ['setOfNumbers'], value: { $add: [20] } },
-  ])
-})
-
-test('$merge on object', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    x: {
-      $merge: false,
-      bla: 'x',
-    },
-  })
-
-  t.true(r.errors.length === 0)
-  t.deepEqual(resultCollect(r), [
-    { path: ['x'], value: { $delete: true } },
-
-    { path: ['x', 'bla'], value: 'x' },
-
-    { path: ['x'], value: { $merge: false, bla: 'x' } },
-  ])
-})
-
-test('$merge on set', async (t) => {
-  r = await setWalker(schema, {
-    $id: 'bl120',
-    $merge: false,
-    x: {
-      bla: 'x',
-    },
-  })
-  t.true(r.errors.length === 0)
-  t.deepEqual(resultCollect(r), [
-    { path: ['x', 'bla'], value: 'x' },
-    { path: ['x'], value: { bla: 'x' } },
-  ])
-})

package/test/string.ts

@@ -1,118 +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: {
-        name: {
-          minLength: 3,
-          maxLength: 6,
-          type: 'string',
-        },
-        phonkName: {
-          type: 'string',
-          pattern: '\\${1,4}',
-        },
-        bla: {
-          type: 'set',
-          items: { type: 'string', minLength: 3, maxLength: 6 },
-        },
-      },
-    },
-  },
-  $defs: {},
-  language: 'en',
-  root: {
-    fields: {},
-  },
-  prefixToTypeMapping: {
-    bl: 'bla',
-  },
-}
-
-test('string max length', async (t) => {
-  const err1 = await setWalker(schema, {
-    $id: 'bl1',
-    name: 'ax',
-  })
-
-  const err2 = await setWalker(schema, {
-    $id: 'bl1',
-    name: 'axaxaxax',
-  })
-  const res1 = await setWalker(schema, {
-    $id: 'bl1',
-    name: 'xaxx',
-  })
-
-  t.assert(errorCollect(err1, err2).length > 0)
-  t.deepEqual(resultCollect(res1), [{ path: ['name'], value: 'xaxx' }])
-})
-
-//set parser
-test('set with strings', async (t) => {
-  const err1 = await setWalker(schema, {
-    $id: 'bl1',
-    bla: ['ax', 'axa', 'axxxxa'],
-  })
-
-  const res1 = await setWalker(schema, {
-    $id: 'bl1',
-    bla: ['axx', 'axxxx', 'blaaa'],
-  })
-
-  t.assert(errorCollect(err1).length > 0)
-  t.deepEqual(resultCollect(res1), [
-    { path: ['bla'], value: { $value: ['axx', 'axxxx', 'blaaa'] } },
-  ])
-})
-
-// this one causes weird array lenght issue in string max length test
-test('string pattern', async (t) => {
-  const err1 = await setWalker(schema, {
-    $id: 'bl1',
-    phonkName: 'blabla',
-  })
-
-  const res1 = await setWalker(schema, {
-    $id: 'bl1',
-    phonkName: 'bla$',
-  })
-
-  t.assert(errorCollect(err1).length > 0)
-  t.deepEqual(resultCollect(res1), [{ path: ['phonkName'], value: 'bla$' }])
-})
-
-test('setting $default', async (t) => {
-  const err = await setWalker(schema, {
-    $id: 'bl1',
-    phonkName: { $default: 'blabla' },
-  })
-
-  t.assert(err.errors.length > 0)
-
-  const res1 = await setWalker(schema, {
-    $id: 'bl1',
-    phonkName: { $default: 'bla$' },
-  })
-
-  t.deepEqual(resultCollect(res1), [
-    { path: ['phonkName'], value: { $default: 'bla$' } },
-  ])
-})
-
-test('setting $value', async (t) => {
-  const err = await setWalker(schema, {
-    $id: 'bl1',
-    phonkName: { $value: 'blabla' },
-  })
-  t.is(err.errors.length, 1)
-  const res1 = await setWalker(schema, {
-    $id: 'bl1',
-    phonkName: { $value: 'bla$' },
-  })
-  t.deepEqual(resultCollect(res1), [{ path: ['phonkName'], value: 'bla$' }])
-})