@based/schema 1.0.7 → 1.0.9

package/src/walker/parse.ts

@@ -1,3 +1,4 @@
+import { deepEqual } from '@saulx/utils'
 import {
   BasedSchemaField,
   BasedSchemaFieldObject,
@@ -7,7 +8,7 @@ import {
 import { ArgsClass } from './args'
 import { ArgsOpts, FieldParser, KeyParser, Stopped } from './types'
 
-type ParseResult<T> = ArgsClass<T> | void
+export type ParseResult<T> = ArgsClass<T> | void
 
 // TODO needs cleaning
 function createOrUseArgs<T>(
@@ -20,7 +21,13 @@ function createOrUseArgs<T>(
   if (newArgs instanceof ArgsClass) {
     return newArgs
   }
-  return from.create(newArgs)
+
+  const x = from.create(newArgs)
+
+  // x.collectedCommands = from.collectedCommands
+  // x.fromBackTrack = from.fromBackTrack
+
+  return x
 }
 
 async function parseKey<T>(
@@ -36,7 +43,11 @@ async function parseKey<T>(
     },
     from
   )
+
+  // if same
+
   const newArgs = createOrUseArgs(keyArgs, await parser(keyArgs))
+
   if (newArgs) {
     return newArgs.parse()
   }
@@ -93,6 +104,7 @@ export async function parse<T>(
     }
     await Promise.all(keyQ)
 
+    // schema
     if (args.stopped === undefined) {
       const fieldQ: Promise<ParseResult<T>>[] = []
       if (args.typeSchema && !args.fieldSchema) {
@@ -135,6 +147,7 @@ export async function parse<T>(
       await Promise.all(fieldQ)
     }
 
+    // any
     if (args.stopped !== Stopped.stopAll) {
       const parser = opts.parsers.any || opts.parsers.catch
       if (parser) {
@@ -148,6 +161,7 @@ export async function parse<T>(
           }
         } else {
           for (const key in args.value) {
+            // console.info('  -> parse field: ', args.path, '->', key)
             if ((!opts.parsers.any && keysHandled.has(key)) || allKeysHandled) {
               continue
             }
@@ -158,24 +172,36 @@ export async function parse<T>(
       }
     }
 
+    // console.log(
+    //   '  OBJECT COMPLETE ------------->',
+    //   args.id,
+    //   args.path,
+    //   'collected: ',
+    //   args.collectedCommands,
+    //   'backtracked: ',
+    //   args.fromBackTrack
+    // )
+
     if (
       opts.backtrack &&
       !args.skipCollection &&
       (args.fromBackTrack.length || args.collectedCommands.length)
     ) {
       const backtracked = opts.backtrack(
-        this,
+        args,
         args.fromBackTrack ?? [],
         args.collectedCommands ?? []
       )
-      if (backtracked && this.prev) {
-        if (!this.prev.fromBackTrack) {
-          this.prev.fromBackTrack = []
+      if (backtracked) {
+        const target = args.getBackTrackTarget()
+        if (!target.fromBackTrack) {
+          target.fromBackTrack = []
         }
-        this.prev.fromBackTrack.push(backtracked)
+        target.fromBackTrack.push(backtracked)
       }
     }
   } else {
+    // more
     if (args.fieldSchema) {
       const fieldParser = getFieldParser(args)
       if (fieldParser) {
@@ -188,6 +214,12 @@ export async function parse<T>(
         const anyParser = opts.parsers.any || opts.parsers.catch
         anyParser(args)
       }
+    } else {
+      // console.info(
+      //   '        ---->',
+      //   'parse non object (no field parser skip)',
+      //   args.path
+      // )
     }
   }
 }

package/test/number.ts

@@ -4,7 +4,7 @@ import {
   BasedSchema,
   BasedSchemaCollectProps,
   BasedSetTarget,
-  setWalker2,
+  setWalker,
 } from '../src/index'
 import { ParseError } from '../src/error'
 import { resultCollect, errorCollect } from './utils'
@@ -54,22 +54,22 @@ const schema: BasedSchema = {
 //todo need help typing this maybe
 
 test('min-max', async (t) => {
-  const e1 = await setWalker2(schema, {
+  const e1 = await setWalker(schema, {
     $id: 'bl1',
     number: 1,
   })
 
-  const e2 = await setWalker2(schema, {
+  const e2 = await setWalker(schema, {
     $id: 'bl1',
     number: 10,
   })
 
-  const res1 = await setWalker2(schema, {
+  const res1 = await setWalker(schema, {
     $id: 'bl1',
     number: 3,
   })
 
-  const res2 = await setWalker2(schema, {
+  const res2 = await setWalker(schema, {
     $id: 'bl1',
     number: 6,
   })
@@ -83,22 +83,22 @@ test('min-max', async (t) => {
 })
 
 test('min-max exclusive', async (t) => {
-  const e1 = await setWalker2(schema, {
+  const e1 = await setWalker(schema, {
     $id: 'bl1',
     exclusiveminmax: 3,
   })
 
-  const e2 = await setWalker2(schema, {
+  const e2 = await setWalker(schema, {
     $id: 'bl1',
     exclusiveminmax: 6,
   })
 
-  const res1 = await setWalker2(schema, {
+  const res1 = await setWalker(schema, {
     $id: 'bl1',
     exclusiveminmax: 4,
   })
 
-  const res2 = await setWalker2(schema, {
+  const res2 = await setWalker(schema, {
     $id: 'bl1',
     exclusiveminmax: 5,
   })
@@ -112,97 +112,97 @@ test('min-max exclusive', async (t) => {
 })
 
 test('isInteger', async (t) => {
-  const e1 = await setWalker2(schema, {
+  const e1 = await setWalker(schema, {
     $id: 'bl1',
     integer: 6.5,
   })
 
-  const res1 = await setWalker2(schema, {
+  const res1 = await setWalker(schema, {
     $id: 'bl1',
     integer: 5,
   })
 
-  t.assert(errorCollect([e1]).length > 0)
-  t.deepEqual(resultCollect([res1]), [{ path: ['integer'], value: 5 }])
+  t.assert(errorCollect(e1).length > 0)
+  t.deepEqual(resultCollect(res1), [{ path: ['integer'], value: 5 }])
 })
 
 test('isMultiple', async (t) => {
-  const e1 = await setWalker2(schema, {
+  const e1 = await setWalker(schema, {
     $id: 'bl1',
     multipleOf: 7,
   })
 
-  const res1 = await setWalker2(schema, {
+  const res1 = await setWalker(schema, {
     $id: 'bl1',
     multipleOf: 9,
   })
 
-  t.assert(errorCollect([e1]).length > 0)
-  t.deepEqual(resultCollect([res1]), [{ path: ['multipleOf'], value: 9 }])
+  t.assert(errorCollect(e1).length > 0)
+  t.deepEqual(resultCollect(res1), [{ path: ['multipleOf'], value: 9 }])
 })
 
 //TODO fix
 test('numbers in a set', async (t) => {
-  const e1 = await setWalker2(schema, {
+  const e1 = await setWalker(schema, {
     $id: 'bl1',
     set: [9, 4, 5, 2],
   })
-  const res1 = await setWalker2(schema, { $id: 'bl1', set: [3, 3, 3, 3] })
+  const res1 = await setWalker(schema, { $id: 'bl1', set: [3, 3, 3, 3] })
 
-  t.assert(errorCollect([e1]).length > 0)
-  t.deepEqual(resultCollect([res1]), [
+  t.assert(errorCollect(e1).length > 0)
+  t.deepEqual(resultCollect(res1), [
     { path: ['set'], value: { $value: [3, 3, 3, 3] } },
   ])
 })
 //TODO fix
 test('value', async (t) => {
-  const e1 = await setWalker2(schema, {
+  const e1 = await setWalker(schema, {
     $id: 'bl1',
     number: { $value: 7 },
   })
-  const e2 = await setWalker2(schema, {
+  const e2 = await setWalker(schema, {
     $id: 'bl1',
     exclusiveminmax: { $value: 3 },
   })
-  const e3 = await setWalker2(schema, {
+  const e3 = await setWalker(schema, {
     $id: 'bl1',
     integer: { value: 3.5 },
   })
 
-  const e4 = await setWalker2(schema, {
+  const e4 = await setWalker(schema, {
     $id: 'bl1',
     set: { $value: [1, 3, 3, 4] },
   })
 
-  const e5 = await setWalker2(schema, {
+  const e5 = await setWalker(schema, {
     $id: 'bl1',
     multipleOf: { $value: 2 },
   })
 
-  const res1 = await setWalker2(schema, {
+  const res1 = await setWalker(schema, {
     $id: 'bl1',
     number: { $value: 4 },
   })
-  const res2 = await setWalker2(schema, {
+  const res2 = await setWalker(schema, {
     $id: 'bl1',
     integer: { $value: 4 },
   })
-  const res3 = await setWalker2(schema, {
+  const res3 = await setWalker(schema, {
     $id: 'bl1',
     exclusiveminmax: { $value: 4 },
   })
-  const res4 = await setWalker2(schema, {
+  const res4 = await setWalker(schema, {
     $id: 'bl1',
     multipleOf: { $value: 6 },
   })
 
-  const res5 = await setWalker2(schema, {
+  const res5 = await setWalker(schema, {
     $id: 'bl1',
     set: { $value: [3, 3, 3, 4] },
   })
 
-  t.assert(errorCollect([e1, e2, e3, e4, e5]).length > 0)
-  t.deepEqual(resultCollect([res1, res2, res3, res4]), [
+  t.assert(errorCollect(e1, e2, e3, e4, e5).length > 0)
+  t.deepEqual(resultCollect(res1, res2, res3, res4), [
     // t.deepEqual(resultCollect([res1, res2, res3, res4, res5]), [
     { path: ['number'], value: 4 },
     { path: ['integer'], value: 4 },
@@ -214,53 +214,58 @@ test('value', async (t) => {
 
 //TODO fix
 test('default', async (t) => {
-  const e1 = await setWalker2(schema, {
+  const e1 = await setWalker(schema, {
     $id: 'bl1',
     number: { $default: 7 },
   })
-  const e2 = await setWalker2(schema, {
+  const e2 = await setWalker(schema, {
     $id: 'bl1',
     exclusiveminmax: { $default: 3 },
   })
-  const e3 = await setWalker2(schema, {
+  const e3 = await setWalker(schema, {
     $id: 'bl1',
     integer: { default: 3.5 },
   })
 
-  const e4 = await setWalker2(schema, {
+  const e4 = await setWalker(schema, {
     $id: 'bl1',
     set: { $default: [1, 3, 3, 4] },
   })
 
-  const e5 = await setWalker2(schema, {
+  const e5 = await setWalker(schema, {
     $id: 'bl1',
     multipleOf: { $default: 2 },
   })
 
-  const res1 = await setWalker2(schema, {
+  const res1 = await setWalker(schema, {
     $id: 'bl1',
     number: { $default: 4 },
   })
-  const res2 = await setWalker2(schema, {
+  const res2 = await setWalker(schema, {
     $id: 'bl1',
     integer: { $default: 4 },
   })
-  const res3 = await setWalker2(schema, {
+  const res3 = await setWalker(schema, {
     $id: 'bl1',
     exclusiveminmax: { $default: 4 },
   })
-  const res4 = await setWalker2(schema, {
+  const res4 = await setWalker(schema, {
     $id: 'bl1',
     multipleOf: { $default: 6 },
   })
 
-  const res5 = await setWalker2(schema, {
+  const res5 = await setWalker(schema, {
     $id: 'bl1',
     set: { $default: [3, 3, 3, 4] },
   })
 
-  t.assert(errorCollect([e1, e2, e3, e4, e5]).length > 0)
-  t.deepEqual(resultCollect([res1, res2, res3, res4, res5]), [
+  //is this issue?
+  console.dir(
+    res5.collected.map((v) => ({ path: v.path, value: v.value })),
+    { depth: 10 }
+  )
+  t.assert(errorCollect(e1, e2, e3, e4, e5).length > 0)
+  t.deepEqual(resultCollect(res1, res2, res3, res4, res5), [
     { path: ['number'], value: { $default: 4 } },
     { path: ['integer'], value: { $default: 4 } },
     { path: ['exclusiveminmax'], value: { $default: 4 } },
@@ -271,58 +276,58 @@ test('default', async (t) => {
 
 test('decrement', async (t) => {
   //maxmin
-  const e1 = await setWalker2(schema, {
+  const e1 = await setWalker(schema, {
     $id: 'bl1',
     number: { $decrement: 2 },
   })
-  const e2 = await setWalker2(schema, {
+  const e2 = await setWalker(schema, {
     $id: 'bl1',
     number: { $decrement: 7 },
   })
 
-  const res1 = await setWalker2(schema, {
+  const res1 = await setWalker(schema, {
     $id: 'bl1',
     number: { $decrement: 3 },
   })
   //exclusiveminmax
-  const e3 = await setWalker2(schema, {
+  const e3 = await setWalker(schema, {
     $id: 'bl1',
     exclusiveminmax: { $decrement: 3 },
   })
-  const e4 = await setWalker2(schema, {
+  const e4 = await setWalker(schema, {
     $id: 'bl1',
     exclusiveminmax: { $decrement: 6 },
   })
 
-  const res2 = await setWalker2(schema, {
+  const res2 = await setWalker(schema, {
     $id: 'bl1',
     exclusiveminmax: { $decrement: 4 },
   })
 
   //integer
-  const e5 = await setWalker2(schema, {
+  const e5 = await setWalker(schema, {
     $id: 'bl1',
     integer: { $decrement: 3.5 },
   })
 
-  const res3 = await setWalker2(schema, {
+  const res3 = await setWalker(schema, {
     $id: 'bl1',
     integer: { $decrement: 3 },
   })
   //multiple of
 
-  const e6 = await setWalker2(schema, {
+  const e6 = await setWalker(schema, {
     $id: 'bl1',
     multipleOf: { $decrement: 7 },
   })
 
-  const res4 = await setWalker2(schema, {
+  const res4 = await setWalker(schema, {
     $id: 'bl1',
     multipleOf: { $decrement: 9 },
   })
 
-  t.assert(errorCollect([e1, e2, e3, e4, e5, e6]).length > 0)
-  t.deepEqual(resultCollect([res1, res2, res3, res4]), [
+  t.assert(errorCollect(e1, e2, e3, e4, e5, e6).length > 0)
+  t.deepEqual(resultCollect(res1, res2, res3, res4), [
     { path: ['number'], value: { $decrement: 3 } },
     { path: ['exclusiveminmax'], value: { $decrement: 4 } },
     { path: ['integer'], value: { $decrement: 3 } },
@@ -332,58 +337,58 @@ test('decrement', async (t) => {
 
 test('increment', async (t) => {
   //maxmin
-  const e1 = await setWalker2(schema, {
+  const e1 = await setWalker(schema, {
     $id: 'bl1',
     number: { $increment: 2 },
   })
-  const e2 = await setWalker2(schema, {
+  const e2 = await setWalker(schema, {
     $id: 'bl1',
     number: { $increment: 7 },
   })
 
-  const res1 = await setWalker2(schema, {
+  const res1 = await setWalker(schema, {
     $id: 'bl1',
     number: { $increment: 3 },
   })
   //exclusiveminmax
-  const e3 = await setWalker2(schema, {
+  const e3 = await setWalker(schema, {
     $id: 'bl1',
     exclusiveminmax: { $increment: 3 },
   })
-  const e4 = await setWalker2(schema, {
+  const e4 = await setWalker(schema, {
     $id: 'bl1',
     exclusiveminmax: { $increment: 6 },
   })
 
-  const res2 = await setWalker2(schema, {
+  const res2 = await setWalker(schema, {
     $id: 'bl1',
     exclusiveminmax: { $increment: 4 },
   })
 
   //integer
-  const e5 = await setWalker2(schema, {
+  const e5 = await setWalker(schema, {
     $id: 'bl1',
     integer: { $increment: 3.5 },
   })
 
-  const res3 = await setWalker2(schema, {
+  const res3 = await setWalker(schema, {
     $id: 'bl1',
     integer: { $increment: 3 },
   })
   //multiple of
 
-  const e6 = await setWalker2(schema, {
+  const e6 = await setWalker(schema, {
     $id: 'bl1',
     multipleOf: { $increment: 7 },
   })
 
-  const res4 = await setWalker2(schema, {
+  const res4 = await setWalker(schema, {
     $id: 'bl1',
     multipleOf: { $increment: 9 },
   })
 
-  t.assert(errorCollect([e1, e2, e3, e4, e5, e6]).length > 0)
-  t.deepEqual(resultCollect([res1, res2, res3, res4]), [
+  t.assert(errorCollect(e1, e2, e3, e4, e5, e6).length > 0)
+  t.deepEqual(resultCollect(res1, res2, res3, res4), [
     { path: ['number'], value: { $increment: 3 } },
     { path: ['exclusiveminmax'], value: { $increment: 4 } },
     { path: ['integer'], value: { $increment: 3 } },