@based/schema 0.0.10 → 0.0.12

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,18 +129,7 @@ const schema: BasedSchema = {
   },
 }
 
-// $noRoot
-// $delete -> change for set / references
-// $merge: false,
-// $assign
-// $insert
-// $remove
-//     $alias: 'maTestWithAlias',
-// aliases (set
-
-// parse push and unshift
-
-test.serial('collect correctly', async (t) => {
+test('collect correctly', async (t) => {
   const results: { path: (string | number)[]; value: any }[] = []
   const now = Date.now()
   await setWalker(
@@ -179,15 +176,10 @@ 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,
@@ -246,6 +238,20 @@ 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 }) => {
         results2.push({
           path,
@@ -279,6 +285,20 @@ 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 }) => {
         results3.push({
           path,
@@ -364,6 +384,20 @@ test('required', 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 }) => {},
       checkRequiredFields: async (paths) => {
         return true
@@ -390,10 +424,23 @@ test('required', 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 }) => {},
       checkRequiredFields: async (paths) => {
         // should be [snurp.x.b, snurp.x.c]
-        console.log(paths)
         return true
       },
       referenceFilterCondition: async (id, filter) => {
@@ -412,3 +459,36 @@ test('required', async (t) => {
 
   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)
+})

package/test/string.ts

@@ -0,0 +1,183 @@
+import test from 'ava'
+import { BasedSchema, setWalker, BasedSetHandlers } from '../src/index'
+
+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: {},
+  languages: ['en'],
+  root: {
+    fields: {},
+  },
+  prefixToTypeMapping: {
+    bl: 'bla',
+  },
+}
+
+const createHandlers = (): {
+  results: { path: (number | string)[]; value: any }[]
+  handlers: BasedSetHandlers
+} => {
+  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('string max length', async (t) => {
+  const { handlers, results } = createHandlers()
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        name: 'ax',
+      },
+      handlers
+    )
+  )
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        name: 'axaxaxax',
+      },
+      handlers
+    )
+  )
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      name: 'xaxx',
+    },
+    handlers
+  )
+  t.deepEqual(results, [{ path: ['name'], value: 'xaxx' }])
+})
+
+test('set with strings', async (t) => {
+  const { handlers, results } = createHandlers()
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        bla: ['ax', 'axa', 'axxxxa'],
+      },
+      handlers
+    )
+  )
+  t.deepEqual(results, [])
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      bla: ['axx', 'axxxx', 'blaaa'],
+    },
+    handlers
+  )
+  t.deepEqual(results, [
+    { path: ['bla'], value: { $value: ['axx', 'axxxx', 'blaaa'] } },
+  ])
+})
+
+test('string pattern', async (t) => {
+  const { handlers, results } = createHandlers()
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        phonkName: 'blabla',
+      },
+      handlers
+    )
+  )
+  t.deepEqual(results, [])
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      phonkName: 'bla$',
+    },
+    handlers
+  )
+  t.deepEqual(results, [{ path: ['phonkName'], value: 'bla$' }])
+})
+
+test('setting $default', async (t) => {
+  const { handlers, results } = createHandlers()
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        phonkName: { $default: 'blabla' },
+      },
+      handlers
+    )
+  )
+  t.deepEqual(results, [])
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      phonkName: { $default: 'bla$' },
+    },
+    handlers
+  )
+  t.deepEqual(results, [{ path: ['phonkName'], value: { $default: 'bla$' } }])
+})
+
+test('setting $value', async (t) => {
+  const { handlers, results } = createHandlers()
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        phonkName: { $value: 'blabla' },
+      },
+      handlers
+    )
+  )
+  t.deepEqual(results, [])
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      phonkName: { $value: 'bla$' },
+    },
+    handlers
+  )
+  t.deepEqual(results, [{ path: ['phonkName'], value: { $value: 'bla$' } }])
+})