@based/schema 1.0.7 → 1.0.9

package/test/text.ts

@@ -0,0 +1,199 @@
+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.only('simple case', async (t) => {
+  let r = await setWalker(schema, {
+    $id: 'bl120',
+    text: { en: 'flap' },
+  })
+  t.deepEqual(resultCollect(r), [{ path: ['text'], value: { en: 'flap' } }])
+  t.true(r.errors.length > 0)
+})
+
+test('string max length', async (t) => {
+  r = await setWalker(schema, {
+    $id: 'bl120',
+    $language: 'za',
+    text: { $value: 'sdsdds' },
+  })
+
+  // TPDP MAKE INTO TEST
+  console.log(
+    r.errors,
+    r.collected.map((v) => ({ path: v.path, value: v.value }))
+  )
+
+  t.true(true)
+})
+
+test('text default', async (t) => {
+  r = await setWalker(schema, {
+    $id: 'bl120',
+    $language: 'za',
+    text: { $default: 'sdsdds' },
+  })
+
+  t.deepEqual(resultCollect(r), [
+    { path: ['text'], value: { $default: { za: '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'],
+      value: { $default: { za: 'sdsdds', en: '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'],
+      value: { $default: { de: 'dsnfds', en: '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'],
+      value: { $default: { de: 'dsnfds', en: 'flapflap' }, nl: 'flapperonus' },
+    },
+  ])
+})
+
+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'],
+      value: {
+        $default: { de: 'dsnfds', en: 'flapflap' },
+        nl: 'flapperonus',
+        ro: 'durp',
+      },
+    },
+  ])
+})
+
+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'],
+      value: {
+        nl: 'flapperonus',
+        $default: { ae: 'habibi', en: 'flapflap' },
+        ro: 'durp',
+      },
+    },
+  ])
+})
+
+test('value:wrongpatter, 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.assert(r.errors.length === 4)
+})

package/test/walker.ts

@@ -86,26 +86,29 @@ const schema: BasedSchema = {
 }
 
 test('walker', async (t) => {
-  const x = await walk(
+  const results: any[] = []
+
+  const setObj = {
+    x: {
+      y: {
+        a: 10,
+        bla: [1, 2, 3, 4, 5],
+      },
+      c: 40,
+    },
+  }
+
+  await walk<{ lullz: true }>(
     schema,
     {
-      init: async (args) => {
-        return { ...args, target: { lullz: true } }
+      init: async () => {
+        return { target: { lullz: true } }
       },
       parsers: {
-        keys: {
-          // $list: async (args) => {
-          //   return {
-          //     ...args,
-          //     value: { flapdrol: true },
-          //   }
-          // },
-        },
-        fields: {
-          // string: () => {}
-        },
+        keys: {},
+        fields: {},
         any: async (args) => {
-          args.collect(args)
+          args.collect()
           return args
         },
       },
@@ -113,47 +116,92 @@ test('walker', async (t) => {
         return args.path.join('.')
       },
       backtrack: (args, fromBt, collected) => {
-        console.log(
-          '    \n-----------BACK TRACK GOOD GO',
-          '\n',
-          'path:',
-          args.path.join('.'),
-          '\n',
-          'backtracked:',
-          JSON.stringify(fromBt),
-          '\n',
-          'collected:',
-          collected,
-          '--------------------'
-        )
+        results.push({ path: args.path, bt: [...fromBt] })
         return fromBt.length ? fromBt : collected
       },
     },
+    setObj
+  )
+
+  t.deepEqual(results, [
+    { path: ['x', 'y', 'bla'], bt: [] },
     {
-      gurk: [1, 2, 3, 4],
-      x: {
-        y: {
-          z: {
-            a: 10,
-            b: 20,
-            gur: {
-              x: true,
-              y: true,
-              $list: {
-                $sort: true,
-              },
-            },
-            c: 40,
-            $list: true,
-          },
+      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']]],
+      ],
+    },
+  ])
+
+  console.log('--------------------------------------')
+  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
   )
 
-  console.info('------------')
+  t.deepEqual(results, results2)
 
-  t.true(true)
+  console.log('--------------------------------------')
+  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('set walker', async (t) => {
@@ -259,7 +307,7 @@ test('set walker', async (t) => {
   t.true(true)
 })
 
-test('perf setWalker', async (t) => {
+test.serial('perf setWalker', async (t) => {
   let d = Date.now()
   let collected = 0
   let errs = 0
@@ -272,10 +320,12 @@ test('perf setWalker', async (t) => {
     errs += x.errors.length
     collected += x.collected.length
   }
+  d = Date.now() - d
+  console.info('setting 200k', d, 'ms')
   t.true(d < 1e3)
 })
 
-test.only('string', async (t) => {
+test('string', async (t) => {
   // for (let i = 0; i < 10; i++) {
   //   console.log(
   //     (await setWalker(schema, { $id: 'bl120', name: 'blax' })).target
@@ -672,8 +722,32 @@ test.only('string', async (t) => {
     },
   })
 
-  r.collected.forEach((v) => {
-    console.info(v.root.typeSchema)
+  console.log(r.errors)
+  console.dir(
+    r.collected.map((v) => ({ path: v.path, value: v.value })),
+    { depth: 10 }
+  )
+
+  console.info('---- doink 27 ------')
+  r = await setWalker(schema, {
+    $id: 'bl120',
+    intarray: {
+      $push: [1, 2, 3, 4, 5],
+    },
+  })
+
+  console.log(r.errors)
+  console.dir(
+    r.collected.map((v) => ({ path: v.path, value: v.value })),
+    { depth: 10 }
+  )
+
+  console.info('---- doink 28 ------')
+  r = await setWalker(schema, {
+    $id: 'bl120',
+    intarray: {
+      $unshift: [1, 2, 3, 4, 5],
+    },
   })
 
   console.log(r.errors)
@@ -682,5 +756,69 @@ test.only('string', async (t) => {
     { depth: 10 }
   )
 
+  console.info('---- doink 29 ------')
+  r = await setWalker(schema, {
+    $id: 'bl120',
+    text: {
+      en: 'bla',
+    },
+  })
+
+  console.dir(
+    r.collected.map((v) => ({ path: v.path, value: v.value })),
+    { depth: 10 }
+  )
+
+  t.true(true)
+
+  console.info('---- doink 30 ------')
+  r = await setWalker(schema, {
+    $id: 'bl120',
+    text: {
+      $delete: true,
+    },
+  })
+
+  console.dir(
+    r.collected.map((v) => ({ path: v.path, value: v.value })),
+    { depth: 10 }
+  )
+
+  console.info('---- doink 31 ------')
+  r = await setWalker(schema, {
+    $id: 'bl120',
+    $delete: true,
+  })
+
+  console.dir(r.errors)
+  console.dir(
+    r.collected.map((v) => ({ path: v.path, value: v.value })),
+    { depth: 10 }
+  )
+
+  console.info('---- doink 32 ------')
+  r = await setWalker(schema, {
+    $id: 'bl120',
+    $alias: 'bla',
+  })
+
+  console.dir(r.errors)
+  console.dir(
+    r.collected.map((v) => ({ path: v.path, value: v.value })),
+    { depth: 10 }
+  )
+
+  console.info('---- doink 33 ------')
+  r = await setWalker(schema, {
+    $id: 'bl120',
+    $alias: ['bla'],
+  })
+
+  console.dir(r.errors)
+  console.dir(
+    r.collected.map((v) => ({ path: v.path, value: v.value })),
+    { depth: 10 }
+  )
+
   t.true(true)
 })