@based/schema 0.0.9 → 0.0.11

package/src/set/collections.ts

@@ -2,6 +2,8 @@ import { Parser } from './types'
 import { error, ParseError } from './error'
 import { fieldWalker } from '.'
 
+// what about making errors return signature
+
 export const set: Parser<'set'> = async (
   path,
   value,
@@ -11,8 +13,19 @@ export const set: Parser<'set'> = async (
   handlers,
   noCollect
 ) => {
+  if (value && typeof value === 'object') {
+    if (value.$default) {
+      error(handlers, ParseError.defaultNotSupported, path)
+    }
+
+    if (value.$value) {
+      value = value.$value
+    }
+  }
+
   const q: Promise<void>[] = []
   const fieldDef = fieldSchema.items
+
   if (Array.isArray(value)) {
     const parsedArray = []
     for (let i = 0; i < value.length; i++) {
@@ -51,12 +64,12 @@ export const set: Parser<'set'> = async (
         )
       }
     }
-    if (value.$delete) {
-      for (let i = 0; i < value.$add.length; i++) {
+    if (value.$remove) {
+      for (let i = 0; i < value.$remove.length; i++) {
         q.push(
           fieldWalker(
             path,
-            value.$delete[i],
+            value.$remove[i],
             fieldDef,
             typeSchema,
             target,
@@ -83,17 +96,20 @@ export const object: Parser<'object'> = async (
   noCollect
 ) => {
   if (typeof value !== 'object') {
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
+    return
   }
   const isArray = Array.isArray(value)
   if (isArray) {
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
+    return
   }
   const q: Promise<void>[] = []
   for (const key in value) {
     const propDef = fieldSchema.properties[key]
     if (!propDef) {
-      error([...path, key], ParseError.fieldDoesNotExist)
+      error(handlers, ParseError.fieldDoesNotExist, [...path, key])
+      continue
     }
     q.push(
       fieldWalker(
@@ -108,9 +124,16 @@ export const object: Parser<'object'> = async (
     )
   }
   await Promise.all(q)
+  if (fieldSchema.required) {
+    for (const req of fieldSchema.required) {
+      if (!(req in value)) {
+        target.required.push([...path, req])
+      }
+    }
+  }
 }
 
-// unshift // only allow 1 command
+// IF REQUIRED AND PUSH OR UNSHIFT just throw here scince we dont need to parse at all...
 export const array: Parser<'array'> = async (
   path,
   value,
@@ -120,13 +143,10 @@ export const array: Parser<'array'> = async (
   handlers,
   noCollect
 ) => {
-  // $value
-
   let isArray = Array.isArray(value)
   let parsedValue = value
   let opCount = 0
   let has$Value = false
-
   if (typeof parsedValue === 'object' && !isArray) {
     if (value.$value) {
       opCount++
@@ -137,13 +157,15 @@ export const array: Parser<'array'> = async (
     if (value.$insert) {
       opCount++
       if (opCount > 1) {
-        error(path, ParseError.multipleOperationsNotAllowed)
+        error(handlers, ParseError.multipleOperationsNotAllowed, path)
+        return
       }
       if (
         typeof value.$insert !== 'object' ||
         value.$insert.$idx === undefined
       ) {
-        error(path, ParseError.incorrectFormat)
+        error(handlers, ParseError.incorrectFormat, path)
+        return
       } else {
         const insert = Array.isArray(value.$insert.$value)
           ? value.$insert.$value
@@ -168,24 +190,29 @@ export const array: Parser<'array'> = async (
     if (value.$remove) {
       opCount++
       if (opCount > 1) {
-        error(path, ParseError.multipleOperationsNotAllowed)
+        error(handlers, ParseError.multipleOperationsNotAllowed, path)
+        return
       }
       if (value.$remove.$idx === undefined) {
-        error(path, ParseError.incorrectFormat)
+        error(handlers, ParseError.incorrectFormat, path)
+        return
       }
     }
     if (value.$push) {
       opCount++
       if (opCount > 1) {
-        error(path, ParseError.multipleOperationsNotAllowed)
+        error(handlers, ParseError.multipleOperationsNotAllowed, path)
+        return
       }
 
+      // TODO: FIX PUSH PARSING
       const q: Promise<void>[] = []
       const push = Array.isArray(value.$push) ? value.$push : [value.$push]
       for (let i = 0; i < push.length; i++) {
         q.push(
           fieldWalker(
-            path,
+            // exception
+            [...path, '$push', i],
             push[i],
             fieldSchema.values,
             typeSchema,
@@ -201,16 +228,20 @@ export const array: Parser<'array'> = async (
     if (value.$unshift) {
       opCount++
       if (opCount > 1) {
-        error(path, ParseError.multipleOperationsNotAllowed)
+        error(handlers, ParseError.multipleOperationsNotAllowed, path)
+        return
       }
       const q: Promise<void>[] = []
       const unshift = Array.isArray(value.$unshift)
         ? value.$unshift
         : [value.$unshift]
+
+      // TODO: FIX UNSHIFT PARSING
       for (let i = 0; i < unshift.length; i++) {
         q.push(
           fieldWalker(
-            path,
+            // exception
+            [...path, '$unshift', i],
             unshift[i],
             fieldSchema.values,
             typeSchema,
@@ -226,13 +257,15 @@ export const array: Parser<'array'> = async (
     if (value.$assign) {
       opCount++
       if (opCount > 1) {
-        error(path, ParseError.multipleOperationsNotAllowed)
+        error(handlers, ParseError.multipleOperationsNotAllowed, path)
+        return
       }
       if (
         typeof value.$assign !== 'object' ||
         typeof value.$assign.$idx !== 'number'
       ) {
-        error(path, ParseError.incorrectFormat)
+        error(handlers, ParseError.incorrectFormat, path)
+        return
       }
       await fieldWalker(
         [...path, value.$assign.$idx],
@@ -259,7 +292,8 @@ export const array: Parser<'array'> = async (
     }
   }
   if (!isArray) {
-    error(path, ParseError.incorrectFieldType)
+    error(handlers, ParseError.incorrectFieldType, path)
+    return
   }
   const q: Promise<void>[] = []
   const collector: any[] = []
@@ -284,6 +318,7 @@ export const array: Parser<'array'> = async (
       )
     )
   }
+
   await Promise.all(q)
 
   if (!noCollect) {

package/src/set/error.ts

@@ -1,3 +1,5 @@
+import { BasedSetHandlers } from '../types'
+
 export enum ParseError {
   'incorrectFieldType',
   'incorrectNodeType',
@@ -9,12 +11,21 @@ export enum ParseError {
   'valueAndDefault',
   'defaultNotSupported',
   'multipleOperationsNotAllowed',
+  'requiredFieldNotDefined',
+  'languageNotSupported',
 }
 
 export const error = (
-  path: (number | string)[],
+  handlers: BasedSetHandlers,
   error: ParseError,
-  type?: string // nice to give as option
+  path?: (number | string)[]
 ) => {
-  throw new Error(`Field: "${path.join('.')}" ${ParseError[error]}`)
+  const message = path
+    ? `${ParseError[error]} ${path.join('.')}`
+    : `${ParseError[error]}`
+
+  handlers.collectErrors({
+    message,
+    code: error,
+  })
 }

package/src/set/index.ts

@@ -4,9 +4,12 @@ import {
   BasedSetHandlers,
   BasedSchema,
   BasedSetTarget,
+  BasedSchemaCollectProps,
+  BasedSetOptionalHandlers,
 } from '../types'
 import { error, ParseError } from './error'
 import parsers from './parsers'
+import { SetOptional } from 'type-fest'
 
 export const fieldWalker = async (
   path: (string | number)[],
@@ -34,13 +37,13 @@ export const fieldWalker = async (
   const typeDef = fieldSchema.type ?? ('enum' in fieldSchema ? 'enum' : '')
 
   if (!typeDef) {
-    error(path, ParseError.fieldDoesNotExist)
+    error(handlers, ParseError.fieldDoesNotExist, path)
   }
 
   if ('customValidator' in fieldSchema) {
     const customValidator = fieldSchema.customValidator
     if (!(await customValidator(value, path, target))) {
-      error(path, ParseError.incorrectFormat)
+      error(handlers, ParseError.incorrectFormat, path)
     }
   }
 
@@ -54,20 +57,51 @@ export const fieldWalker = async (
 export const setWalker = async (
   schema: BasedSchema,
   value: { [key: string]: any },
-  handlers: BasedSetHandlers
+  inHandlers: BasedSetOptionalHandlers
 ): Promise<BasedSetTarget> => {
+  let errors: {
+    message: string
+    code: ParseError
+  }[]
+
+  const collect: BasedSchemaCollectProps[] = []
+
+  const x = { ...inHandlers }
+
+  if (!('collectErrors' in x)) {
+    errors = []
+    x.collectErrors = (info) => {
+      errors.push(info)
+    }
+  }
+
+  let prevCollect: any
+
+  if (!('collect' in x)) {
+    x.collect = (info) => {
+      collect.push(info)
+    }
+  } else {
+    prevCollect = x.collect
+    x.collect = (info) => {
+      collect.push(info)
+    }
+  }
+
+  const handlers: BasedSetHandlers = <BasedSetHandlers>x
+
   let type: string
 
   if (value.$id) {
     type = schema.prefixToTypeMapping[value.$id.slice(0, 2)]
     if (!type) {
-      error([value.$id], ParseError.incorrectNodeType)
+      error(handlers, ParseError.incorrectNodeType, [value.$id])
     }
   }
 
   if (value.type) {
     if (type && value.type !== type) {
-      error([value.$id, value.type], ParseError.incorrectNodeType)
+      error(handlers, ParseError.incorrectNodeType, [value.$id, value.type])
     }
     type = value.type
   }
@@ -75,12 +109,20 @@ export const setWalker = async (
   const schemaType = schema.types[type]
 
   if (!schemaType) {
-    error([type], ParseError.incorrectNodeType)
+    error(handlers, ParseError.incorrectNodeType, [type])
   }
 
   const target: BasedSetTarget = {
     type,
     schema,
+    required: [],
+  }
+
+  if (value.$language) {
+    if (!schema.languages.includes(value.$language)) {
+      error(handlers, ParseError.languageNotSupported, ['$language'])
+    }
+    target.$language = value.$language
   }
 
   if (value.$id) {
@@ -92,10 +134,10 @@ export const setWalker = async (
   const q: Promise<void>[] = []
 
   for (const key in value) {
-    if (key[0] !== '$') {
+    if (key[0] !== '$' && key !== 'type') {
       const fieldSchema = schemaType.fields[key]
       if (!fieldSchema) {
-        error([key], ParseError.fieldDoesNotExist)
+        error(handlers, ParseError.fieldDoesNotExist, [key])
       } else {
         q.push(
           fieldWalker(
@@ -113,10 +155,43 @@ export const setWalker = async (
 
   await Promise.all(q)
 
-  // required fields (collect them!)
-  //   if (!(await handlers.requiredFields(value, [], target))) {
-  //     throw new Error('Missing required fields')
-  //   }
+  if (schemaType.required) {
+    for (const req of schemaType.required) {
+      if (!(req in value)) {
+        target.required.push([req])
+      }
+    }
+  }
+
+  if (target.required?.length) {
+    const requireDefined = await Promise.all(
+      target.required.map(async (req) => {
+        return handlers.checkRequiredFields(req)
+      })
+    )
+    for (let i = 0; i < requireDefined.length; i++) {
+      if (!requireDefined[i]) {
+        const r = target.required[i]
+        error(handlers, ParseError.requiredFieldNotDefined, r)
+      }
+    }
+  }
+
+  if (errors?.length) {
+    const err = new Error(
+      'Errors in in set' +
+        errors.reduce((str, info) => {
+          return str + `\n - ${info.message}`
+        }, '')
+    )
+    throw err
+  }
+
+  if (prevCollect) {
+    for (const x of collect) {
+      prevCollect(x)
+    }
+  }
 
   return target
 }

package/src/set/number.ts

@@ -4,21 +4,25 @@ import {
   BasedSchemaFieldInteger,
   BasedSchemaFieldNumber,
   BasedSchemaFieldTimeStamp,
+  BasedSetHandlers,
 } from '../types'
 
 const validate = (
+  handlers: BasedSetHandlers,
   path: (number | string)[],
   value: any,
   fieldSchema:
     | BasedSchemaFieldInteger
     | BasedSchemaFieldNumber
     | BasedSchemaFieldTimeStamp
-): number => {
+): number | false => {
   if (typeof value !== 'number') {
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
+    return false
   }
   if (fieldSchema.type === 'integer' && value - Math.floor(value) !== 0) {
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
+    return false
   }
   if (
     fieldSchema.multipleOf &&
@@ -26,26 +30,36 @@ const validate = (
       Math.floor(value / fieldSchema.multipleOf) !==
       0
   ) {
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
+    return false
   }
   if (fieldSchema.maximum) {
-    if (fieldSchema.exclusiveMaximum && value > value) {
-      error(path, ParseError.exceedsMaximum)
-    } else if (value >= value) {
-      error(path, ParseError.exceedsMaximum)
+    if (fieldSchema.exclusiveMaximum) {
+      if (value >= fieldSchema.maximum) {
+        error(handlers, ParseError.exceedsMaximum, path)
+        return false
+      }
+    } else if (value > fieldSchema.maximum) {
+      error(handlers, ParseError.exceedsMaximum, path)
+      return false
     }
   }
   if (fieldSchema.minimum) {
-    if (fieldSchema.exclusiveMinimum && value < value) {
-      error(path, ParseError.subceedsMinimum)
-    } else if (value <= value) {
-      error(path, ParseError.subceedsMinimum)
+    if (fieldSchema.exclusiveMinimum) {
+      if (value <= fieldSchema.minimum) {
+        error(handlers, ParseError.subceedsMinimum, path)
+        return false
+      }
+    } else if (value < fieldSchema.minimum) {
+      error(handlers, ParseError.subceedsMinimum, path)
+      return false
     }
   }
   return value
 }
 
 const shared = (
+  handlers: BasedSetHandlers,
   path: (number | string)[],
   value: any,
   fieldSchema:
@@ -55,22 +69,23 @@ const shared = (
 ): any => {
   if (typeof value === 'object') {
     if (value.$increment) {
-      validate([...path, '$increment'], value.$increment, fieldSchema)
+      validate(handlers, [...path, '$increment'], value.$increment, fieldSchema)
     }
     if (value.$decrement) {
-      validate([...path, '$decrement'], value.$decrement, fieldSchema)
+      validate(handlers, [...path, '$decrement'], value.$decrement, fieldSchema)
     }
     if (value.$value !== undefined) {
-      validate(path, value.$value, fieldSchema)
+      validate(handlers, path, value.$value, fieldSchema)
     }
     if (value.$default !== undefined) {
       if (value.$value !== undefined) {
-        error(path, ParseError.valueAndDefault)
+        error(handlers, ParseError.valueAndDefault, path)
+        return
       }
-      validate(path, value.$default, fieldSchema)
+      validate(handlers, path, value.$default, fieldSchema)
     }
   } else {
-    validate(path, value, fieldSchema)
+    validate(handlers, path, value, fieldSchema)
   }
   return value
 }
@@ -85,17 +100,19 @@ export const timestamp: Parser<'timestamp'> = async (
   noCollect
 ) => {
   if (typeof value === 'string') {
+    // TODO: now + 10 and stuff
     if (value === 'now') {
       value = Date.now()
     } else {
       const d = new Date(value)
       value = d.valueOf()
       if (isNaN(value)) {
-        error(path, ParseError.incorrectFormat)
+        error(handlers, ParseError.incorrectFormat, path)
+        return
       }
     }
   }
-  const parsedValue = shared(path, value, fieldSchema)
+  const parsedValue = shared(handlers, path, value, fieldSchema)
   if (!noCollect) {
     handlers.collect({
       path,
@@ -116,7 +133,7 @@ export const number: Parser<'number'> = async (
   handlers,
   noCollect
 ) => {
-  const parsedValue = shared(path, value, fieldSchema)
+  const parsedValue = shared(handlers, path, value, fieldSchema)
   if (!noCollect) {
     handlers.collect({
       path,
@@ -137,7 +154,7 @@ export const integer: Parser<'integer'> = async (
   handlers,
   noCollect
 ) => {
-  const parsedValue = shared(path, value, fieldSchema)
+  const parsedValue = shared(handlers, path, value, fieldSchema)
   if (!noCollect) {
     handlers.collect({
       path,

package/src/set/parseDefaultAndValue.ts

@@ -18,14 +18,23 @@ export const parseValueAndDefault: Parser<keyof BasedSchemaFields> = async (
     const parse = parsers[typeDef]
     if (value.$value !== undefined) {
       // TODO: for errors handle path a bit smarter...
-      parse(path, value.$value, fieldSchema, typeSchema, target, handlers, true)
+      await parse(
+        path,
+        value.$value,
+        fieldSchema,
+        typeSchema,
+        target,
+        handlers,
+        true
+      )
       handled = true
     }
     if (value.$default !== undefined) {
       if (value.$value !== undefined) {
-        error(path, ParseError.valueAndDefault)
+        error(handlers, ParseError.valueAndDefault, path)
       }
-      parse(
+      console.info('->', path, 'go')
+      await parse(
         path,
         value.$default,
         fieldSchema,
@@ -38,6 +47,7 @@ export const parseValueAndDefault: Parser<keyof BasedSchemaFields> = async (
     }
   }
   if (handled && !noCollect) {
+    console.log('collect?')
     handlers.collect({ path, value, typeSchema, fieldSchema, target })
   }
   return handled

package/src/set/references.ts

@@ -16,14 +16,15 @@ export const reference: Parser<'reference'> = async (
   // $value
 
   if (typeof value !== 'string') {
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
   }
 
   if ('allowedTypes' in fieldSchema) {
     const prefix = value.slice(0, 2)
     const targetType = target.schema.prefixToTypeMapping[prefix]
     if (!targetType) {
-      error(path, ParseError.referenceIsIncorrectType)
+      error(handlers, ParseError.referenceIsIncorrectType, path)
+      return
     }
     let typeMatches = false
     for (const t of fieldSchema.allowedTypes) {
@@ -37,18 +38,21 @@ export const reference: Parser<'reference'> = async (
           typeMatches = true
           if (t.$filter) {
             if (!(await handlers.referenceFilterCondition(value, t.$filter))) {
-              error(path, ParseError.referenceIsIncorrectType)
+              error(handlers, ParseError.referenceIsIncorrectType, path)
+              return
             }
           }
         } else if (!t.type && t.$filter) {
           if (!(await handlers.referenceFilterCondition(value, t.$filter))) {
-            error(path, ParseError.referenceIsIncorrectType)
+            error(handlers, ParseError.referenceIsIncorrectType, path)
+            return
           }
         }
       }
     }
     if (typeMatches === false) {
-      error(path, ParseError.referenceIsIncorrectType)
+      error(handlers, ParseError.referenceIsIncorrectType, path)
+      return
     }
   }
   if (!noCollect) {
@@ -100,6 +104,8 @@ export const references: Parser<'references'> = async (
         })
       )
     }
+  } else {
+    error(handlers, ParseError.incorrectFormat, path)
   }
   if (!noCollect) {
     handlers.collect({ path, value, typeSchema, fieldSchema, target })

package/src/set/rest.ts

@@ -15,7 +15,7 @@ export const cardinality: Parser<'cardinality'> = async (
 ) => {
   if (value && typeof value === 'object') {
     if (value.$default !== undefined) {
-      error(path, ParseError.defaultNotSupported)
+      error(handlers, ParseError.defaultNotSupported, path)
     }
     if (value.$value !== undefined) {
       value = hashObjectIgnoreKeyOrder(value.$value).toString(16)
@@ -54,7 +54,7 @@ export const boolean: Parser<'boolean'> = async (
   }
 
   if (typeof value !== 'boolean') {
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
   }
 
   if (!noCollect) {
@@ -91,7 +91,7 @@ export const enumParser: Parser<'enum'> = async (
         return
       }
     }
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
   }
 }
 
@@ -130,6 +130,6 @@ export const json: Parser<'json'> = async (
       })
     }
   } catch (err) {
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
   }
 }