@based/schema 0.0.6 → 0.0.8

package/src/set/collections.ts

@@ -8,53 +8,45 @@ export const set: Parser<'set'> = async (
   fieldSchema,
   typeSchema,
   target,
-  handlers
+  handlers,
+  noCollect
 ) => {
   const q: Promise<void>[] = []
   const fieldDef = fieldSchema.items
   if (Array.isArray(value)) {
-    const handlerNest = {
-      ...handlers,
-      collect: ({ value }) => {
-        parsedArray.push(value)
-      },
-    }
     const parsedArray = []
     for (let i = 0; i < value.length; i++) {
       q.push(
-        fieldWalker(
-          [...path, i],
-          value[i],
-          fieldDef,
-          typeSchema,
-          target,
-          handlerNest
-        )
+        fieldWalker([...path, i], value[i], fieldDef, typeSchema, target, {
+          ...handlers,
+          collect: ({ value }) => {
+            parsedArray.push(value)
+          },
+        })
       )
     }
     await Promise.all(q)
-    handlers.collect({
-      path,
-      value: { $value: parsedArray },
-      typeSchema,
-      fieldSchema,
-      target,
-    })
-  } else {
-    const handlerNest = {
-      ...handlers,
-      collect: () => {},
+    if (!noCollect) {
+      handlers.collect({
+        path,
+        value: { $value: parsedArray },
+        typeSchema,
+        fieldSchema,
+        target,
+      })
     }
+  } else {
     if (value.$add) {
       for (let i = 0; i < value.$add.length; i++) {
         q.push(
           fieldWalker(
-            [...path, '$add', i],
+            path,
             value.$add[i],
             fieldDef,
             typeSchema,
             target,
-            handlerNest
+            handlers,
+            true
           )
         )
       }
@@ -63,18 +55,21 @@ export const set: Parser<'set'> = async (
       for (let i = 0; i < value.$add.length; i++) {
         q.push(
           fieldWalker(
-            [...path, '$delete', i],
+            path,
             value.$delete[i],
             fieldDef,
             typeSchema,
             target,
-            handlerNest
+            handlers,
+            true
           )
         )
       }
     }
     await Promise.all(q)
-    handlers.collect({ path, value, typeSchema, fieldSchema, target })
+    if (!noCollect) {
+      handlers.collect({ path, value, typeSchema, fieldSchema, target })
+    }
   }
 }
 
@@ -84,7 +79,8 @@ export const object: Parser<'object'> = async (
   fieldSchema,
   typeSchema,
   target,
-  handlers
+  handlers,
+  noCollect
 ) => {
   if (typeof value !== 'object') {
     error(path, ParseError.incorrectFormat)
@@ -106,127 +102,153 @@ export const object: Parser<'object'> = async (
         propDef,
         typeSchema,
         target,
-        handlers
+        handlers,
+        noCollect
       )
     )
   }
   await Promise.all(q)
 }
 
+// unshift // only allow 1 command
 export const array: Parser<'array'> = async (
   path,
   value,
   fieldSchema,
   typeSchema,
   target,
-  handlers
+  handlers,
+  noCollect
 ) => {
   const isArray = Array.isArray(value)
+  let parsedValue = value
+  let opCount = 0
   if (typeof value === 'object' && !isArray) {
     if (value.$insert) {
+      opCount++
       if (
         typeof value.$insert !== 'object' ||
         value.$insert.$idx === undefined
       ) {
-        error([...path, '$insert'], ParseError.incorrectFormat)
+        error(path, ParseError.incorrectFormat)
       } else {
-        const nestedHandler = {
-          ...handlers,
-          collect: () => {},
-        }
+        const insert = Array.isArray(value.$insert.$value)
+          ? value.$insert.$value
+          : [value.$insert.$value]
         const q: Promise<void>[] = []
-        if (Array.isArray(value.$insert.$value)) {
-          for (let i = 0; i < value.$insert.$value.length; i++) {
-            q.push(
-              fieldWalker(
-                [...path, 'insert', i],
-                value.$insert.$value[i],
-                fieldSchema.values,
-                typeSchema,
-                target,
-                nestedHandler
-              )
-            )
-          }
-        } else {
+        for (let i = 0; i < insert.length; i++) {
           q.push(
             fieldWalker(
-              [...path, '$insert'],
-              value.$insert.$value,
+              path,
+              insert[i],
               fieldSchema.values,
               typeSchema,
               target,
-              nestedHandler
+              handlers,
+              true
             )
           )
         }
         await Promise.all(q)
       }
     }
-    if (value.$remove && value.$remove.$idx === undefined) {
-      error([...path, '$remove'], ParseError.incorrectFormat)
+    if (value.$remove) {
+      opCount++
+      if (opCount > 1) {
+        error(path, ParseError.multipleOperationsNotAllowed)
+      }
+      if (value.$remove.$idx === undefined) {
+        error(path, ParseError.incorrectFormat)
+      }
     }
     if (value.$push) {
-      const q: Promise<void>[] = []
-      const nestedHandler = {
-        ...handlers,
-        collect: () => {},
+      opCount++
+      if (opCount > 1) {
+        error(path, ParseError.multipleOperationsNotAllowed)
       }
-      if (Array.isArray(value.$push)) {
-        for (let i = 0; i < value.$push.length; i++) {
-          q.push(
-            fieldWalker(
-              [...path, i],
-              value.$push[i],
-              fieldSchema.values,
-              typeSchema,
-              target,
-              nestedHandler
-            )
+
+      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,
+            push[i],
+            fieldSchema.values,
+            typeSchema,
+            target,
+            handlers,
+            true
           )
-        }
-      } else {
+        )
+      }
+      await Promise.all(q)
+      parsedValue = { $push: push }
+    }
+    if (value.$unshift) {
+      opCount++
+      if (opCount > 1) {
+        error(path, ParseError.multipleOperationsNotAllowed)
+      }
+
+      const q: Promise<void>[] = []
+      const unshift = Array.isArray(value.$unshift)
+        ? value.$unshift
+        : [value.$unshift]
+      for (let i = 0; i < unshift.length; i++) {
         q.push(
           fieldWalker(
-            [...path, '$push'],
-            value.$push,
+            path,
+            unshift[i],
             fieldSchema.values,
             typeSchema,
             target,
-            nestedHandler
+            handlers,
+            true
           )
         )
       }
       await Promise.all(q)
+      parsedValue = { $unshift: unshift }
     }
     if (value.$assign) {
+      opCount++
+      if (opCount > 1) {
+        error(path, ParseError.multipleOperationsNotAllowed)
+      }
+
       if (
         typeof value.$assign !== 'object' ||
         value.$assign.$idx === undefined
       ) {
-        error([...path, '$assign'], ParseError.incorrectFormat)
+        error(path, ParseError.incorrectFormat)
       } else {
         await fieldWalker(
-          [...path, '$assign', '$value'],
+          path,
           value.$assign.$value,
           fieldSchema.values,
           typeSchema,
           target,
-          {
-            ...handlers,
-            collect: () => {},
-          }
+          handlers,
+          true
         )
       }
     }
-    handlers.collect({ path, value, typeSchema, fieldSchema, target })
+
+    if (!noCollect) {
+      handlers.collect({
+        path,
+        value: parsedValue,
+        typeSchema,
+        fieldSchema,
+        target,
+      })
+    }
     return
   }
-
   if (!isArray) {
     error(path, ParseError.incorrectFieldType)
   }
-
   const q: Promise<void>[] = []
   for (let i = 0; i < value.length; i++) {
     q.push(
@@ -236,7 +258,8 @@ export const array: Parser<'array'> = async (
         fieldSchema.values,
         typeSchema,
         target,
-        handlers
+        handlers,
+        noCollect
       )
     )
   }

package/src/set/error.ts

@@ -6,6 +6,9 @@ export enum ParseError {
   'fieldDoesNotExist',
   'incorrectFormat',
   'referenceIsIncorrectType',
+  'valueAndDefault',
+  'defaultNotSupported',
+  'multipleOperationsNotAllowed',
 }
 
 export const error = (

package/src/set/index.ts

@@ -14,7 +14,8 @@ export const fieldWalker = async (
   fieldSchema: BasedSchemaField,
   typeSchema: BasedSchemaType,
   target: BasedSetTarget,
-  handlers: BasedSetHandlers
+  handlers: BasedSetHandlers,
+  noCollect?: boolean
 ): Promise<void> => {
   if ('$ref' in fieldSchema) {
     // TODO: when we have this it has to get it from the schema and redo the parsing with the correct fieldSchema
@@ -24,7 +25,9 @@ export const fieldWalker = async (
 
   const valueIsObject = value && valueType === 'object'
   if (valueIsObject && value.$delete === true) {
-    handlers.collect({ path, value, typeSchema, fieldSchema, target })
+    if (!noCollect) {
+      handlers.collect({ path, value, typeSchema, fieldSchema, target })
+    }
     return
   }
 
@@ -43,7 +46,7 @@ export const fieldWalker = async (
 
   const parse = parsers[typeDef]
 
-  await parse(path, value, fieldSchema, typeSchema, target, handlers)
+  await parse(path, value, fieldSchema, typeSchema, target, handlers, noCollect)
 
   return
 }

package/src/set/number.ts

@@ -1,5 +1,79 @@
 import { Parser } from './types'
 import { error, ParseError } from './error'
+import {
+  BasedSchemaFieldInteger,
+  BasedSchemaFieldNumber,
+  BasedSchemaFieldTimeStamp,
+} from '../types'
+
+const validate = (
+  path: (number | string)[],
+  value: any,
+  fieldSchema:
+    | BasedSchemaFieldInteger
+    | BasedSchemaFieldNumber
+    | BasedSchemaFieldTimeStamp
+): number => {
+  if (typeof value !== 'number') {
+    error(path, ParseError.incorrectFormat)
+  }
+  if (fieldSchema.type === 'integer' && value - Math.floor(value) !== 0) {
+    error(path, ParseError.incorrectFormat)
+  }
+  if (
+    fieldSchema.multipleOf &&
+    value / fieldSchema.multipleOf -
+      Math.floor(value / fieldSchema.multipleOf) !==
+      0
+  ) {
+    error(path, ParseError.incorrectFormat)
+  }
+  if (fieldSchema.maximum) {
+    if (fieldSchema.exclusiveMaximum && value > value) {
+      error(path, ParseError.exceedsMaximum)
+    } else if (value >= value) {
+      error(path, ParseError.exceedsMaximum)
+    }
+  }
+  if (fieldSchema.minimum) {
+    if (fieldSchema.exclusiveMinimum && value < value) {
+      error(path, ParseError.subceedsMinimum)
+    } else if (value <= value) {
+      error(path, ParseError.subceedsMinimum)
+    }
+  }
+  return value
+}
+
+const shared = (
+  path: (number | string)[],
+  value: any,
+  fieldSchema:
+    | BasedSchemaFieldInteger
+    | BasedSchemaFieldNumber
+    | BasedSchemaFieldTimeStamp
+): any => {
+  if (typeof value === 'object') {
+    if (value.$increment) {
+      validate([...path, '$increment'], value.$increment, fieldSchema)
+    }
+    if (value.$decrement) {
+      validate([...path, '$decrement'], value.$decrement, fieldSchema)
+    }
+    if (value.$value !== undefined) {
+      validate(path, value.$value, fieldSchema)
+    }
+    if (value.$default !== undefined) {
+      if (value.$value !== undefined) {
+        error(path, ParseError.valueAndDefault)
+      }
+      validate(path, value.$default, fieldSchema)
+    }
+  } else {
+    validate(path, value, fieldSchema)
+  }
+  return value
+}
 
 export const timestamp: Parser<'timestamp'> = async (
   path,
@@ -7,7 +81,8 @@ export const timestamp: Parser<'timestamp'> = async (
   fieldSchema,
   typeSchema,
   target,
-  handlers
+  handlers,
+  noCollect
 ) => {
   if (typeof value === 'string') {
     if (value === 'now') {
@@ -16,31 +91,20 @@ export const timestamp: Parser<'timestamp'> = async (
       const d = new Date(value)
       value = d.valueOf()
       if (isNaN(value)) {
-        throw error(path, ParseError.incorrectFormat)
+        error(path, ParseError.incorrectFormat)
       }
     }
   }
-  // // smaller then / larger then steps
-  // if (typeof value !== 'number') {
-  //   throw createError(path, target.type, 'timestamp', value)
-  // }
-
-  // if (fieldSchema.maximum) {
-  //   if (fieldSchema.exclusiveMaximum && value > value) {
-  //     throw createError(path, target.type, 'timestamp', value)
-  //   } else if (value >= value) {
-  //     throw createError(path, target.type, 'timestamp', value)
-  //   }
-  // }
-
-  // if (fieldSchema.minimum) {
-  //   if (fieldSchema.exclusiveMinimum && value < value) {
-  //     throw createError(path, target.type, 'timestamp', value)
-  //   } else if (value <= value) {
-  //     throw createError(path, target.type, 'timestamp', value)
-  //   }
-  // }
-  handlers.collect({ path, value, typeSchema, fieldSchema, target })
+  const parsedValue = shared(path, value, fieldSchema)
+  if (!noCollect) {
+    handlers.collect({
+      path,
+      value: parsedValue,
+      typeSchema,
+      fieldSchema,
+      target,
+    })
+  }
 }
 
 export const number: Parser<'number'> = async (
@@ -49,16 +113,19 @@ export const number: Parser<'number'> = async (
   fieldSchema,
   typeSchema,
   target,
-  handlers
+  handlers,
+  noCollect
 ) => {
-  // value .default
-  // $increment / $decrement
-
-  if (typeof value !== 'number') {
-    error(path, ParseError.incorrectFormat)
+  const parsedValue = shared(path, value, fieldSchema)
+  if (!noCollect) {
+    handlers.collect({
+      path,
+      value: parsedValue,
+      typeSchema,
+      fieldSchema,
+      target,
+    })
   }
-
-  handlers.collect({ path, value, typeSchema, fieldSchema, target })
 }
 
 export const integer: Parser<'integer'> = async (
@@ -67,12 +134,17 @@ export const integer: Parser<'integer'> = async (
   fieldSchema,
   typeSchema,
   target,
-  handlers
+  handlers,
+  noCollect
 ) => {
-  // value .default
-  // $increment / $decrement
-  if (typeof value !== 'number' || value - Math.floor(value) !== 0) {
-    error(path, ParseError.incorrectFormat)
+  const parsedValue = shared(path, value, fieldSchema)
+  if (!noCollect) {
+    handlers.collect({
+      path,
+      value: parsedValue,
+      typeSchema,
+      fieldSchema,
+      target,
+    })
   }
-  handlers.collect({ path, value, typeSchema, fieldSchema, target })
 }

package/src/set/parseDefaultAndValue.ts

@@ -0,0 +1,44 @@
+import { BasedSchemaFields } from '../types'
+import { Parser } from './types'
+import { error, ParseError } from './error'
+import parsers from './parsers'
+
+export const parseValueAndDefault: Parser<keyof BasedSchemaFields> = async (
+  path,
+  value,
+  fieldSchema,
+  typeSchema,
+  target,
+  handlers,
+  noCollect
+): Promise<boolean> => {
+  let handled = false
+  if (typeof value === 'object') {
+    const typeDef = fieldSchema.type ?? ('enum' in fieldSchema ? 'enum' : '')
+    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)
+      handled = true
+    }
+    if (value.$default !== undefined) {
+      if (value.$value !== undefined) {
+        error(path, ParseError.valueAndDefault)
+      }
+      parse(
+        path,
+        value.$default,
+        fieldSchema,
+        typeSchema,
+        target,
+        handlers,
+        true
+      )
+      handled = true
+    }
+  }
+  if (handled && !noCollect) {
+    handlers.collect({ path, value, typeSchema, fieldSchema, target })
+  }
+  return handled
+}

package/src/set/references.ts

@@ -7,7 +7,8 @@ export const reference: Parser<'reference'> = async (
   fieldSchema,
   typeSchema,
   target,
-  handlers
+  handlers,
+  noCollect
 ) => {
   // $no root
   // prob pass these as options
@@ -50,7 +51,9 @@ export const reference: Parser<'reference'> = async (
       error(path, ParseError.referenceIsIncorrectType)
     }
   }
-  handlers.collect({ path, value, typeSchema, fieldSchema, target })
+  if (!noCollect) {
+    handlers.collect({ path, value, typeSchema, fieldSchema, target })
+  }
 }
 
 export const references: Parser<'references'> = async (
@@ -59,15 +62,12 @@ export const references: Parser<'references'> = async (
   fieldSchema,
   typeSchema,
   target,
-  handlers
+  handlers,
+  noCollect
 ) => {
   // default
   // $no root
   if (Array.isArray(value)) {
-    const handler = {
-      ...handlers,
-      collect: () => {},
-    }
     await Promise.all(
       value.map((v, i) => {
         return reference(
@@ -77,17 +77,14 @@ export const references: Parser<'references'> = async (
           { ...fieldSchema, type: 'reference' },
           typeSchema,
           target,
-          handler
+          handlers,
+          true
         )
       })
     )
     value = { $value: value }
   } else if (typeof value === 'object') {
     if (value.$add) {
-      const handler = {
-        ...handlers,
-        collect: () => {},
-      }
       await Promise.all(
         value.$add.map((v, i) => {
           return reference(
@@ -97,11 +94,14 @@ export const references: Parser<'references'> = async (
             { ...fieldSchema, type: 'reference' },
             typeSchema,
             target,
-            handler
+            handlers,
+            true
           )
         })
       )
     }
   }
-  handlers.collect({ path, value, typeSchema, fieldSchema, target })
+  if (!noCollect) {
+    handlers.collect({ path, value, typeSchema, fieldSchema, target })
+  }
 }