@based/schema 0.0.9 → 0.0.11

package/test/reference.ts

@@ -0,0 +1,207 @@
+import test from 'ava'
+import { BasedSchema, setWalker, BasedSetOptionalHandlers } from '../src/index'
+
+const schema: BasedSchema = {
+  types: {
+    bla: {
+      prefix: 'bl',
+      fields: {
+        ref: {
+          type: 'reference',
+          allowedTypes: ['bla'],
+        },
+        ref2: {
+          type: 'references',
+          allowedTypes: ['bla'],
+        },
+        arr: {
+          type: 'array',
+          title: '',
+        },
+      },
+    },
+  },
+  $defs: {},
+  languages: ['en'],
+  root: {
+    fields: {},
+  },
+  prefixToTypeMapping: {
+    bl: 'bla',
+  },
+}
+
+const createHandlers = (): {
+  results: { path: (number | string)[]; value: any }[]
+  handlers: BasedSetOptionalHandlers
+} => {
+  const results: { path: (number | string)[]; value: any }[] = []
+  const handlers = {
+    collect: ({ path, value, typeSchema, fieldSchema, target }) => {
+      results.push({ path, value })
+    },
+    checkRequiredFields: async (paths) => {
+      return true
+    },
+    referenceFilterCondition: async (id, filter) => {
+      return true
+    },
+  }
+  return { results, handlers }
+}
+
+test('reference', async (t) => {
+  const { handlers, results } = createHandlers()
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        ref: ['1', '2'],
+      },
+      handlers
+    )
+  )
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        ref: 1,
+      },
+      handlers
+    )
+  )
+
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      ref: 'asdasdasdasdasd',
+    },
+    handlers
+  )
+  t.deepEqual(results, [{ path: ['ref'], value: 'asdasdasdasdasd' }])
+})
+
+test('multiple references', async (t) => {
+  const { handlers, results } = createHandlers()
+
+  // await t.throwsAsync(
+  //   setWalker(
+  //     schema,
+  //     {
+  //       $id: 'bl1',
+  //       ref2: 0.5,
+  //     },
+  //     handlers
+  //   )
+  // )
+  // await t.throwsAsync(
+  //   setWalker(
+  //     schema,
+  //     {
+  //       $id: 'bl1',
+  //       ref2: 1,
+  //     },
+  //     handlers
+  //   )
+  // )
+  // these should throw, array of refs doesnt
+  //??? todo?
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        ref2: [1, 1, 1, 1, 1, 1, 1],
+      },
+      handlers
+    )
+  )
+  console.log(results)
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      ref2: ['1', '2', '3'],
+    },
+    handlers
+  )
+  t.deepEqual(results, [{ path: ['ref2'], value: { $value: ['1', '2', '3'] } }])
+})
+
+test('value of references', async (t) => {
+  const { handlers, results } = createHandlers()
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        ref: { $value: ['1', '2'] },
+      },
+      handlers
+    )
+  )
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        ref: { $value: 1 },
+      },
+      handlers
+    )
+  )
+
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      ref: { $value: 'asdasdasdasdasd' },
+    },
+    handlers
+  )
+  console.log('------------>', results)
+  //error here?
+  t.deepEqual(results, [
+    { path: ['ref'], value: { $value: 'asdasdasdasdasd' } },
+  ])
+})
+test.only('default of references', async (t) => {
+  const { handlers, results } = createHandlers()
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        ref: { $default: ['1', '2'] },
+      },
+      handlers
+    )
+  )
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        ref: { $default: 1 },
+      },
+      handlers
+    )
+  )
+
+  // await setWalker(
+  //   schema,
+  //   {
+  //     $id: 'bl1',
+  //     ref: { $default: 'asdasdasdasdasd' },
+  //   },
+  //   handlers
+  // )
+  // console.log('------------>', results)
+  // //error here?
+  // t.deepEqual(results, [
+  //   { path: ['ref'], value: { $default: 'asdasdasdasdasd' } },
+  // ])
+})

package/test/setWalker.ts

@@ -15,6 +15,14 @@ const schema: BasedSchema = {
         flap: {
           type: 'number',
         },
+        snurpobject: {
+          type: 'object',
+          properties: {
+            x: {
+              type: 'string',
+            },
+          },
+        },
         snurp: {
           type: 'array',
           values: {
@@ -121,29 +129,7 @@ const schema: BasedSchema = {
   },
 }
 
-// $value
-// $default
-
-// $noRoot
-
-// $delete -> change for set / references
-
-// $merge: false,
-
-// $increment
-// $decrement
-
-// $assign
-// $insert
-// $remove
-// $push: 7,
-// $unshift (    $unshift: {$value: 123,$maxLen: 10,},)
-//     $alias: 'maTestWithAlias',
-// aliases (set
-
-// parse formats for string e.g. uri / email etc
-
-test.serial('collect correctly', async (t) => {
+test('collect correctly', async (t) => {
   const results: { path: (string | number)[]; value: any }[] = []
   const now = Date.now()
   await setWalker(
@@ -159,7 +145,7 @@ test.serial('collect correctly', async (t) => {
         $increment: 1,
       },
       bla: false,
-      time: now, // do more later
+      time: now,
       setje: [1, 2, 3],
       form: {
         lastName: 'de beer',
@@ -190,20 +176,18 @@ test.serial('collect correctly', async (t) => {
       ],
     },
     {
+      collectErrors: (info) => {
+        // fix fields (too heavy)
+      },
       collect: ({ path, value, typeSchema, fieldSchema, target }) => {
-        console.dir(
-          {
-            path,
-            value,
-          },
-          { depth: 10 }
-        )
-
         results.push({
           path,
           value,
         })
       },
+      checkRequiredFields: async (path) => {
+        return true
+      },
       referenceFilterCondition: async (id, filter) => {
         return true
       },
@@ -219,7 +203,6 @@ test.serial('collect correctly', async (t) => {
       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}' },
@@ -227,14 +210,12 @@ test.serial('collect correctly', async (t) => {
     { 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 },
@@ -242,12 +223,8 @@ test.serial('collect correctly', async (t) => {
     { path: ['snurp', 0, 'x', 2], value: 3 },
   ]
 
-  console.log(results)
-
   t.deepEqual(results, result)
 
-  console.info('DID COMPARSION!')
-
   const results2: any[] = []
   await setWalker(
     schema,
@@ -261,19 +238,29 @@ test.serial('collect correctly', async (t) => {
       },
     },
     {
+      collectErrors: (info) => {
+        // {
+        //   path,
+        //   value,
+        //   typeSchema,
+        //   fieldSchema,
+        //   target,
+        //   code,
+        //   message,
+        // }
+
+        console.error(info.message)
+        // fix fields (too heavy)
+      },
       collect: ({ path, value, typeSchema, fieldSchema, target }) => {
-        console.dir(
-          {
-            path,
-            value,
-          },
-          { depth: 10 }
-        )
         results2.push({
           path,
           value,
         })
       },
+      checkRequiredFields: async (path) => {
+        return false
+      },
       referenceFilterCondition: async (id, filter) => {
         return true
       },
@@ -298,19 +285,29 @@ test.serial('collect correctly', async (t) => {
       },
     },
     {
+      collectErrors: (info) => {
+        // {
+        //   path,
+        //   value,
+        //   typeSchema,
+        //   fieldSchema,
+        //   target,
+        //   code,
+        //   message,
+        // }
+
+        console.error(info.message)
+        // fix fields (too heavy)
+      },
       collect: ({ path, value, typeSchema, fieldSchema, target }) => {
-        console.dir(
-          {
-            path,
-            value,
-          },
-          { depth: 10 }
-        )
         results3.push({
           path,
           value,
         })
       },
+      checkRequiredFields: async (path) => {
+        return false
+      },
       referenceFilterCondition: async (id, filter) => {
         return true
       },
@@ -322,3 +319,176 @@ test.serial('collect correctly', async (t) => {
     { 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)
+})