@based/schema 1.0.8 → 1.0.9

package/test/set.ts

@@ -0,0 +1,116 @@
+// import test from 'ava'
+// import { BasedSchema, setWalker, walk } from '../src/index'
+// import { wait } from '@saulx/utils'
+
+// const schema: BasedSchema = {
+//   types: {
+//     thing: {
+//       prefix: 'ti',
+//       fields: {
+//         something: { type: 'string', format: 'strongPassword' },
+//       },
+//     },
+//     bla: {
+//       prefix: 'bl',
+//       fields: {
+//         referencesToThings: {
+//           type: 'references',
+//           allowedTypes: ['thing'],
+//         },
+//         referenceToThing: {
+//           type: 'reference',
+//           allowedTypes: ['thing'],
+//         },
+//         exclusiveminmax: {
+//           type: 'number',
+//           minimum: 3,
+//           exclusiveMinimum: true,
+//           maximum: 6,
+//           exclusiveMaximum: true,
+//         },
+//         text: {
+//           type: 'text',
+//           pattern: '[^xz]{1,10}',
+//         },
+//         timestamp: {
+//           type: 'timestamp',
+//         },
+//         setOfNumbers: {
+//           type: 'set',
+//           items: {
+//             type: 'number',
+//           },
+//         },
+//         x: {
+//           type: 'object',
+//           properties: {
+//             flap: {
+//               type: 'boolean',
+//             },
+//           },
+//         },
+//         bla: {
+//           type: 'set',
+//           items: { type: 'string', minLength: 3, maxLength: 6 },
+//         },
+//       },
+//     },
+//   },
+//   $defs: {},
+//   languages: ['en', 'de', 'nl', 'ro', 'za', 'ae'],
+//   root: {
+//     fields: {},
+//   },
+//   prefixToTypeMapping: {
+//     bl: 'bla',
+//     ti: 'thing',
+//   },
+// }
+
+// console.info('---- doink 15 ------')
+// r = await setWalker(schema, {
+//   $id: 'bl120',
+//   setOfNumbers: [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 16 ------')
+// r = await setWalker(schema, {
+//   $id: 'bl120',
+//   setOfNumbers: { $add: 20 },
+// })
+
+// console.log(r.errors)
+// console.dir(
+//   r.collected.map((v) => ({ path: v.path, value: v.value })),
+//   { depth: 10 }
+// )
+
+// console.info('---- doink 17 ------')
+// r = await setWalker(schema, {
+//   $id: 'bl120',
+//   setOfNumbers: { $add: [1, 2, 3, 4, 5, 6] },
+// })
+
+// console.log(r.errors)
+// console.dir(
+//   r.collected.map((v) => ({ path: v.path, value: v.value })),
+//   { depth: 10 }
+// )
+
+// console.info('---- doink 18 ------')
+// r = await setWalker(schema, {
+//   $id: 'bl120',
+//   setOfNumbers: { $remove: [1, 2, 3, 4, 5, 6] },
+// })
+
+// console.log(r.errors)
+// console.dir(
+//   r.collected.map((v) => ({ path: v.path, value: v.value })),
+//   { depth: 10 }
+// )

package/test/string.ts

@@ -1,139 +1,121 @@
-// import test from 'ava'
-// import { BasedSchema, setWalker2 } 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',
-//   },
-// }
-
-// test('string max length', async (t) => {
-//   const err1 = await setWalker2(schema, {
-//     $id: 'bl1',
-//     name: 'ax',
-//   })
-
-//   const err2 = await setWalker2(schema, {
-//     $id: 'bl1',
-//     name: 'axaxaxax',
-//   })
-//   const res1 = await setWalker2(schema, {
-//     $id: 'bl1',
-//     name: 'xaxx',
-//   })
-
-//   console.log(err1.errors)
-//   console.log(err2.errors)
-//   const err = [err2.errors]
-//   const res = [res1]
-
-//   // t.assert(err[0].length === 2)
-//   t.deepEqual(res[0].target.collected, [{ path: ['name'], value: 'xaxx' }])
-// })
-
-// //set parser
-// test('set with strings', async (t) => {
-//   const err1 = setWalker2(schema, {
-//     $id: 'bl1',
-//     bla: ['ax', 'axa', 'axxxxa'],
-//   })
-
-//   const res1 = await setWalker2(schema, {
-//     $id: 'bl1',
-//     bla: ['axx', 'axxxx', 'blaaa'],
-//   })
-
-//   const err = [(await err1).errors]
-//   const res = [await res1]
-
-//   // t.assert(err[0].length === 1)
-//   t.deepEqual(res[0].target.collected, [
-//     { 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 setWalker2(schema, {
-//     $id: 'bl1',
-//     phonkName: 'blabla',
-//   })
-
-//   const res1 = await setWalker2(schema, {
-//     $id: 'bl1',
-//     phonkName: 'bla$',
-//   })
-
-//   const err = [err1.errors]
-
-//   const res = [res1]
-//   // t.assert(err[0].length === 1)
-//   t.deepEqual(res[0].target.collected, [{ path: ['phonkName'], value: 'bla$' }])
-// })
-
-// test('setting $default', async (t) => {
-//   const err = await setWalker2(schema, {
-//     $id: 'bl1',
-//     phonkName: { $default: 'blabla' },
-//   })
-//   t.assert(err.errors.length > 1)
-
-//   const res1 = await setWalker2(schema, {
-//     $id: 'bl1',
-//     phonkName: { $default: 'bla$' },
-//   })
-
-//   const res = [res1]
-//   console.log(res) // is ok
-//   console.log(res1) // isnt ok???
-
-//   t.deepEqual(res[0].target.collected, [
-//     { path: ['phonkName'], value: { $default: 'bla$' } },
-//   ])
-// })
-
-// test('setting $value', async (t) => {
-//   const err = await setWalker2(schema, {
-//     $id: 'bl1',
-//     phonkName: { $value: 'blabla' },
-//   })
-//   t.assert(err.errors.length > 1)
-
-//   const res1 = await setWalker2(schema, {
-//     $id: 'bl1',
-//     phonkName: { $value: 'bla$' },
-//   })
-
-//   const res = [res1]
-//   console.log(res) // is ok
-//   console.log(res1) // isnt ok???
-
-//   t.deepEqual(res[0].target.collected, [
-//     { path: ['phonkName'], value: { $value: 'bla$' } },
-//   ])
-// })
+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: {},
+  languages: ['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.assert(err.errors.length > 1)
+
+  const res1 = await setWalker(schema, {
+    $id: 'bl1',
+    phonkName: { $value: 'bla$' },
+  })
+
+  t.deepEqual(resultCollect(res1), [{ path: ['phonkName'], value: 'bla$' }])
+})

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)
+})