@based/schema 0.0.15 → 1.0.1

package/test/reference.ts

@@ -1,207 +1,159 @@
-import test from 'ava'
-import { BasedSchema, setWalker, BasedSetOptionalHandlers } from '../src/index'
+// import test from 'ava'
+// import { BasedSchema, setWalker2 } from '../src/index'
+// import { resultCollect, errorCollect } from './utils'
 
-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 schema: BasedSchema = {
+//   types: {
+//     bla: {
+//       prefix: 'bl',
+//       fields: {
+//         ref: {
+//           type: 'reference',
+//           allowedTypes: ['bl', 'bl1'],
+//         },
+//         ref2: {
+//           type: 'references',
+//           allowedTypes: ['bl'],
+//         },
+//         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 e1 = await setWalker2(schema, {
+//     $id: 'bl1',
+//     ref: ['1', '2'],
+//   })
+//   const e2 = await setWalker2(schema, {
+//     $id: 'bl1',
+//     ref: 1,
+//   })
 
-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
-    )
-  )
+//   const res = await setWalker2(schema, {
+//     $id: 'bl1',
+//     ref: 'asdasdasdasdasd',
+//   })
 
-  await setWalker(
-    schema,
-    {
-      $id: 'bl1',
-      ref: 'asdasdasdasdasd',
-    },
-    handlers
-  )
-  t.deepEqual(results, [{ path: ['ref'], value: 'asdasdasdasdasd' }])
-})
+//   t.assert(errorCollect([e1, e2]).length > 0)
+//   t.deepEqual(resultCollect([res]), [
+//     { path: ['ref'], value: 'asdasdasdasdasd' },
+//   ])
+// })
 
-test('multiple references', async (t) => {
-  const { handlers, results } = createHandlers()
+// test('multiple references', async (t) => {
+//   // const e = await (
+//   //   setWalker2(
+//   //     schema,
+//   //     {
+//   //       $id: 'bl1',
+//   //       ref2: 0.5,
+//   //     },
+//   //
+//   //   )
+//   // )
+//   // const e = await (
+//   //   setWalker2(
+//   //     schema,
+//   //     {
+//   //       $id: 'bl1',
+//   //       ref2: 1,
+//   //     },
+//   //
+//   //   )
+//   // )
+//   // these should throw, array of refs doesnt
+//   //??? todo?
+//   const e = await setWalker2(schema, {
+//     $id: 'bl1',
+//     ref2: [1, 1, 1, 1, 1, 1, 1],
+//   })
+//   const res1 = await setWalker2(schema, {
+//     $id: 'bl1',
+//     ref2: ['1', '2', '3'],
+//   })
 
-  // 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'] } }])
-})
+//   t.assert(errorCollect([e]).length === 1)
+//   t.deepEqual(resultCollect([res1]), [
+//     { 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
-    )
-  )
+// test('value of references', async (t) => {
+//   const e = await setWalker2(schema, {
+//     $id: 'bl1',
+//     ref: { $value: ['1', '2'] },
+//   })
+//   const e1 = await setWalker2(schema, {
+//     $id: 'bl1',
+//     ref: { $value: 1 },
+//   })
 
-  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
-    )
-  )
+//   const res1 = await setWalker2(schema, {
+//     $id: 'bl1',
+//     ref: { $value: 'asdasdasdasdasd' },
+//   })
 
-  // await setWalker(
-  //   schema,
-  //   {
-  //     $id: 'bl1',
-  //     ref: { $default: 'asdasdasdasdasd' },
-  //   },
-  //   handlers
-  // )
-  // console.log('------------>', results)
-  // //error here?
-  // t.deepEqual(results, [
-  //   { path: ['ref'], value: { $default: 'asdasdasdasdasd' } },
-  // ])
-})
+//   //error here?
+//   t.assert(errorCollect([e, e1]).length === 2)
+//   t.deepEqual(resultCollect([res1]), [
+//     { path: ['ref'], value: { $value: 'asdasdasdasdasd' } },
+//   ])
+// })
+
+// test('default of references', async (t) => {
+//   const e2 = await setWalker2(schema, {
+//     $id: 'bl1',
+//     ref: { $default: ['1', '2'] },
+//   })
+//   const e1 = await setWalker2(schema, {
+//     $id: 'bl1',
+//     ref: { $default: 1 },
+//   })
+
+//   // await setWalker2(
+//   //   schema,
+//   //   {
+//   //     $id: 'bl1',
+//   //     ref: { $default: 'asdasdasdasdasd' },
+//   //   },
+//   //
+//   // )
+//   // console.log('----:XX', resultCollect)
+//   // //error here?
+//   // t.deepEqual(resultCollect, [
+//   //   { path: ['ref'], value: { $default: 'asdasdasdasdasd' } },
+//   // ])
+//   t.assert(errorCollect([e2, e1]).length === 2)
+// })
+
+// test.only('allowedTypes', async (t) => {
+//   const e1 = await setWalker2(schema, {
+//     $id: 'bl1',
+//     ref: ['1', '2'],
+//   })
+//   const e2 = await setWalker2(schema, {
+//     $id: 'bs1',
+//     ref: 1,
+//   })
+//   const res1 = await setWalker2(schema, {
+//     $id: 'bl1',
+//     ref: 'blastuff',
+//   })
+
+//   t.assert(errorCollect([e2, e1]).length === 2)
+//   t.deepEqual(resultCollect([res1]), [{ path: ['ref'], value: 'bl1stuff' }])
+//   // is this wrong or am i wrong
+// })

package/test/rest.ts

@@ -0,0 +1,227 @@
+import test from 'ava'
+import { BasedSchema, setWalker, BasedSetOptionalHandlers } from '../src/index'
+
+const schema: BasedSchema = {
+  types: {
+    bla: {
+      prefix: 'bl',
+      fields: {
+        arrNum: {
+          type: 'array',
+          values: {
+            type: 'number',
+          },
+        },
+        arrStr: {
+          type: 'array',
+          values: {
+            type: 'string',
+          },
+        },
+      },
+    },
+  },
+  $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('arrayNum', async (t) => {
+  const { handlers, results } = createHandlers()
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        arrNum: ['1', '2'],
+      },
+      handlers
+    )
+  )
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bla',
+        ref: 1,
+      },
+      handlers
+    )
+  )
+
+  await setWalker(
+    schema,
+    {
+      $id: 'bla',
+      arrNum: [1, 2],
+    },
+    handlers
+  )
+  t.deepEqual(results, [
+    { path: ['arrNum'], value: { $delete: true } },
+    { path: ['arrNum', 0], value: 1 },
+    { path: ['arrNum', 1], value: 2 },
+  ])
+})
+
+test.only('value arr', async (t) => {
+  const { handlers, results } = createHandlers()
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        arrNum: { $value: ['1', '2'] },
+      },
+      handlers
+    )
+  )
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bla',
+        ref: { $value: 1 },
+      },
+      handlers
+    )
+  )
+
+  await setWalker(
+    schema,
+    {
+      $id: 'bla',
+      arrNum: [{ $value: 1 }, { $value: 2 }],
+    },
+    handlers
+  )
+  await setWalker(
+    schema,
+    {
+      $id: 'bla',
+      arrNum: { $value: [1, 2] },
+    },
+    handlers
+  )
+  console.log(results)
+  t.deepEqual(results, [
+    { path: ['arrNum'], value: { $delete: true } },
+    { path: ['arrNum', 0], value: { $value: 1 } }, // just 1
+    { path: ['arrNum', 1], value: { $value: 2 } }, // just 2
+    { path: ['arrNum'], value: { $delete: true } },
+    { path: ['arrNum', 0], value: 1 },
+    { path: ['arrNum', 1], value: 2 },
+  ])
+})
+
+test('default arr', async (t) => {
+  const { handlers, results } = createHandlers()
+
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bl1',
+        arrNum: ['1', '2'],
+      },
+      handlers
+    )
+  )
+  await t.throwsAsync(
+    setWalker(
+      schema,
+      {
+        $id: 'bla',
+        ref: 1,
+      },
+      handlers
+    )
+  )
+
+  await setWalker(
+    schema,
+    {
+      $id: 'bla',
+      arrNum: [{ $default: 1 }, { $default: 2 }],
+    },
+    handlers
+  )
+  await setWalker(
+    schema,
+    {
+      $id: 'bla',
+      arrNum: { $default: [1, 2] },
+    },
+    handlers
+  )
+  console.log(results)
+  //is this correct? is it supposed to be different
+  t.deepEqual(results, [
+    { path: ['arrNum'], value: { $delete: true } },
+    { path: ['arrNum', 0], value: { $default: 1 } },
+    { path: ['arrNum', 1], value: { $default: 2 } },
+    // why are theese two different but for defaultits the same
+    { path: ['arrNum'], value: { $default: [1, 2] } },
+  ])
+})
+// test('arrStr', async (t) => {
+//   const { handlers, results } = createHandlers()
+//   await t.throwsAsync(
+//     setWalker(
+//       schema,
+//       {
+//         $id: 'bl1',
+//         arrStr: [1, '2'],
+//       },
+//       handlers
+//     )
+//   )
+//   await t.throwsAsync(
+//     setWalker(
+//       schema,
+//       {
+//         $id: 'bla',
+//         ref: 1,
+//       },
+//       handlers
+//     )
+//   )
+
+//   await setWalker(
+//     schema,
+//     {
+//       $id: 'bla',
+//       arrStr: [1, 2],
+//     },
+//     handlers
+//   )
+//   t.deepEqual(results, [
+//     { path: ['arrStr'], value: { $delete: true } },
+//     { path: ['arrStr', 0], value: 1 },
+//     { path: ['arrStr', 1], value: 2 },
+//   ])
+// })