@based/schema 0.0.6 → 0.0.8

package/src/set/rest.ts

@@ -2,6 +2,7 @@ import { Parser } from './types'
 import { deepEqual } from '@saulx/utils'
 import { hashObjectIgnoreKeyOrder, hash } from '@saulx/hash'
 import { error, ParseError } from './error'
+import { parseValueAndDefault } from './parseDefaultAndValue'
 
 export const cardinality: Parser<'cardinality'> = async (
   path,
@@ -9,14 +10,24 @@ export const cardinality: Parser<'cardinality'> = async (
   fieldSchema,
   typeSchema,
   target,
-  handlers
+  handlers,
+  noCollect
 ) => {
   if (value && typeof value === 'object') {
-    value = hashObjectIgnoreKeyOrder(value).toString(16)
+    if (value.$default !== undefined) {
+      error(path, ParseError.defaultNotSupported)
+    }
+    if (value.$value !== undefined) {
+      value = hashObjectIgnoreKeyOrder(value.$value).toString(16)
+    } else {
+      value = hashObjectIgnoreKeyOrder(value).toString(16)
+    }
   } else {
     value = hash(value).toString(16)
   }
-  handlers.collect({ path, value, typeSchema, fieldSchema, target })
+  if (!noCollect) {
+    handlers.collect({ path, value, typeSchema, fieldSchema, target })
+  }
 }
 
 export const boolean: Parser<'boolean'> = async (
@@ -25,14 +36,30 @@ export const boolean: Parser<'boolean'> = async (
   fieldSchema,
   typeSchema,
   target,
-  handlers
+  handlers,
+  noCollect
 ) => {
-  // value .default
-  // $increment / $decrement
+  if (
+    await parseValueAndDefault(
+      path,
+      value,
+      fieldSchema,
+      typeSchema,
+      target,
+      handlers,
+      noCollect
+    )
+  ) {
+    return
+  }
+
   if (typeof value !== 'boolean') {
     error(path, ParseError.incorrectFormat)
   }
-  handlers.collect({ path, value, typeSchema, fieldSchema, target })
+
+  if (!noCollect) {
+    handlers.collect({ path, value, typeSchema, fieldSchema, target })
+  }
 }
 
 export const enumParser: Parser<'enum'> = async (
@@ -41,16 +68,31 @@ export const enumParser: Parser<'enum'> = async (
   fieldSchema,
   typeSchema,
   target,
-  handlers
+  handlers,
+  noCollect
 ) => {
   const enumValues = fieldSchema.enum
-  for (let i = 0; i < enumValues.length; i++) {
-    if (deepEqual(enumValues[i], value)) {
-      handlers.collect({ path, value: i, typeSchema, fieldSchema, target })
-      return
+  if (
+    !(await parseValueAndDefault(
+      path,
+      value,
+      fieldSchema,
+      typeSchema,
+      target,
+      handlers,
+      noCollect
+    ))
+  ) {
+    for (let i = 0; i < enumValues.length; i++) {
+      if (deepEqual(enumValues[i], value)) {
+        if (!noCollect) {
+          handlers.collect({ path, value: i, typeSchema, fieldSchema, target })
+        }
+        return
+      }
     }
+    error(path, ParseError.incorrectFormat)
   }
-  error(path, ParseError.incorrectFormat)
 }
 
 export const json: Parser<'json'> = async (
@@ -59,18 +101,35 @@ export const json: Parser<'json'> = async (
   fieldSchema,
   typeSchema,
   target,
-  handlers
+  handlers,
+  noCollect
 ) => {
-  try {
-    const parsedValue = JSON.stringify(value)
-    handlers.collect({
+  if (
+    await parseValueAndDefault(
       path,
-      value: parsedValue,
-      typeSchema,
+      value,
       fieldSchema,
+      typeSchema,
       target,
-    })
+      handlers,
+      noCollect
+    )
+  ) {
+    return
+  }
+
+  try {
+    const parsedValue = JSON.stringify(value)
+    if (!noCollect) {
+      handlers.collect({
+        path,
+        value: parsedValue,
+        typeSchema,
+        fieldSchema,
+        target,
+      })
+    }
   } catch (err) {
-    throw err(path, ParseError.incorrectFormat)
+    error(path, ParseError.incorrectFormat)
   }
 }

package/src/set/string.ts

@@ -2,6 +2,7 @@ import { Parser } from './types'
 import { error, ParseError } from './error'
 import { BasedSchemaFieldString, BasedSchemaFieldText } from '../types'
 import validators from 'validator'
+import { parseValueAndDefault } from './parseDefaultAndValue'
 
 const formatPatterns: Record<
   BasedSchemaFieldString['format'],
@@ -101,10 +102,26 @@ export const string: Parser<'string'> = async (
   fieldSchema,
   typeSchema,
   target,
-  handlers
+  handlers,
+  noCollect
 ) => {
+  if (
+    await parseValueAndDefault(
+      path,
+      value,
+      fieldSchema,
+      typeSchema,
+      target,
+      handlers,
+      noCollect
+    )
+  ) {
+    return
+  }
   validate(path, value, fieldSchema)
-  handlers.collect({ path, value, typeSchema, fieldSchema, target })
+  if (!noCollect) {
+    handlers.collect({ path, value, typeSchema, fieldSchema, target })
+  }
 }
 
 export const text: Parser<'text'> = async (
@@ -113,18 +130,21 @@ export const text: Parser<'text'> = async (
   fieldSchema,
   typeSchema,
   target,
-  handlers
+  handlers,
+  noCollect
 ) => {
   const valueType = typeof value
   if (target.$language && valueType === 'string') {
     validate(path, value, fieldSchema)
-    handlers.collect({
-      path,
-      value: { [target.$language]: value },
-      typeSchema,
-      fieldSchema,
-      target,
-    })
+    if (!noCollect) {
+      handlers.collect({
+        path,
+        value: { [target.$language]: value },
+        typeSchema,
+        fieldSchema,
+        target,
+      })
+    }
     return
   }
 
@@ -132,28 +152,60 @@ export const text: Parser<'text'> = async (
     error(path, ParseError.incorrectFormat)
   }
 
+  if (
+    target.$language &&
+    (await parseValueAndDefault(
+      path,
+      value,
+      fieldSchema,
+      typeSchema,
+      target,
+      handlers,
+      noCollect
+    ))
+  ) {
+    return
+  }
+
   for (const key in value) {
     const newPath = [...path, key]
 
-    if (typeof value[key] === 'object' && value[key].$delete === true) {
+    if (typeof value[key] === 'object') {
+      if (value[key].$value) {
+        text(
+          [...path, key, '$value'],
+          value[key].$value,
+          fieldSchema,
+          typeSchema,
+          target,
+          handlers,
+          true
+        )
+      }
+      if (!noCollect) {
+        handlers.collect({
+          path: newPath,
+          value: null,
+          typeSchema,
+          fieldSchema,
+          target,
+        })
+      }
+      continue
+    }
+
+    // if
+
+    // validate(newPath, value[key], fieldSchema)
+
+    if (!noCollect) {
       handlers.collect({
         path: newPath,
-        value: null,
+        value: value[key],
         typeSchema,
         fieldSchema,
         target,
       })
-      continue
     }
-
-    validate(newPath, value[key], fieldSchema)
-
-    handlers.collect({
-      path: newPath,
-      value: value[key],
-      typeSchema,
-      fieldSchema,
-      target,
-    })
   }
 }

package/src/set/types.ts

@@ -11,8 +11,9 @@ export type Parser<K extends keyof BasedSchemaFields> = (
   fieldSchema: BasedSchemaFields[K],
   typeSchema: BasedSchemaType,
   target: BasedSetTarget,
-  handlers: BasedSetHandlers
-) => Promise<void>
+  handlers: BasedSetHandlers,
+  noCollect?: boolean
+) => Promise<void | boolean>
 
 export type Parsers = {
   [Key in keyof BasedSchemaFields]: Parser<Key>

package/test/setWalker.ts

@@ -9,6 +9,12 @@ const schema: BasedSchema = {
         visits: {
           type: 'cardinality',
         },
+        blub: {
+          type: 'number',
+        },
+        flap: {
+          type: 'number',
+        },
         snurp: {
           type: 'array',
           values: {
@@ -149,6 +155,9 @@ test.serial('collect correctly', async (t) => {
         snurp: false,
         ua: '123435',
       },
+      blub: {
+        $increment: 1,
+      },
       bla: false,
       time: now, // do more later
       setje: [1, 2, 3],
@@ -203,16 +212,17 @@ test.serial('collect correctly', async (t) => {
 
   const result = [
     { path: ['visits'], value: '3a9009740ee' },
-    { path: ['bla'], value: false },
+    { path: ['blub'], value: { $increment: 1 } },
     { path: ['time'], value: now },
-    { path: ['form', 'lastName'], value: 'de beer' },
-    { path: ['form', 'json'], value: '{"bla":1,"x":2,"y":3}' },
     { path: ['form', 'snurp'], value: 'blx12' },
-    { path: ['form', 'things'], value: 2 },
-    { path: ['form', 'password'], value: 'mypassword!' },
     { path: ['snurp', 0, 'x', 0], value: 1 },
     { path: ['snurp', 0, 'x', 1], value: 2 },
     { path: ['snurp', 0, 'x', 2], value: 3 },
+    { path: ['bla'], value: false },
+    { path: ['form', 'lastName'], value: 'de beer' },
+    { path: ['form', 'json'], value: '{"bla":1,"x":2,"y":3}' },
+    { path: ['form', 'things'], value: 2 },
+    { path: ['form', 'password'], value: 'mypassword!' },
     { path: ['form', 'bla'], value: { $value: ['bl123', 'bl234'] } },
     { path: ['form', 'blab'], value: { $add: ['bl456'] } },
     {
@@ -227,5 +237,83 @@ test.serial('collect correctly', async (t) => {
     },
   ]
 
+  console.log(results)
+
   t.deepEqual(results, result)
+
+  console.info('DID COMPARSION!')
+
+  const results2: any[] = []
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      blub: {
+        $value: 4,
+      },
+      flap: {
+        $default: 1,
+      },
+    },
+    {
+      collect: ({ path, value, typeSchema, fieldSchema, target }) => {
+        console.dir(
+          {
+            path,
+            value,
+          },
+          { depth: 10 }
+        )
+        results2.push({
+          path,
+          value,
+        })
+      },
+      referenceFilterCondition: async (id, filter) => {
+        return true
+      },
+    }
+  )
+
+  t.deepEqual(results2, [
+    { path: ['blub'], value: { $value: 4 } },
+    { path: ['flap'], value: { $default: 1 } },
+  ])
+
+  const results3: any[] = []
+  await setWalker(
+    schema,
+    {
+      $id: 'bl1',
+      snurpArray: {
+        $push: 1,
+      },
+      specialArray: {
+        $push: { $value: 'flap' },
+      },
+    },
+    {
+      collect: ({ path, value, typeSchema, fieldSchema, target }) => {
+        console.dir(
+          {
+            path,
+            value,
+          },
+          { depth: 10 }
+        )
+        results3.push({
+          path,
+          value,
+        })
+      },
+      referenceFilterCondition: async (id, filter) => {
+        return true
+      },
+    }
+  )
+
+  t.deepEqual(results3, [
+    { path: ['snurpArray'], value: { $push: [1] } },
+    { path: ['specialArray'], value: { $push: [{ $value: 'flap' }] } },
+  ])
 })

package/dist/parse.d.ts

@@ -1,2 +0,0 @@
-import { BasedSchema } from './schema';
-export declare const parseSchema: (schema: BasedSchema) => BasedSchema;

package/dist/parse.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSchema = void 0;
-const parseSchema = (schema) => {
-    // rewrite schema things like required / required: []
-    return schema;
-};
-exports.parseSchema = parseSchema;
-//# sourceMappingURL=parse.js.map

package/dist/parse.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse.js","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":";;;AAEO,MAAM,WAAW,GAAG,CAAC,MAAmB,EAAe,EAAE;IAC9D,qDAAqD;IAErD,OAAO,MAAM,CAAA;AACf,CAAC,CAAA;AAJY,QAAA,WAAW,eAIvB"}