@based/schema 0.0.6 → 0.0.7

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,62 @@
 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.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) {
+      validate([...path], value.$value, fieldSchema)
+    }
+  } else {
+    validate(path, value, fieldSchema)
+  }
+  return value
+}
 
 export const timestamp: Parser<'timestamp'> = async (
   path,
@@ -7,7 +64,8 @@ export const timestamp: Parser<'timestamp'> = async (
   fieldSchema,
   typeSchema,
   target,
-  handlers
+  handlers,
+  noCollect
 ) => {
   if (typeof value === 'string') {
     if (value === 'now') {
@@ -20,27 +78,16 @@ export const timestamp: Parser<'timestamp'> = async (
       }
     }
   }
-  // // 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 +96,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 +117,20 @@ 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) {
+  if (typeof value === 'number' && value - Math.floor(value) !== 0) {
     error(path, ParseError.incorrectFormat)
   }
-  handlers.collect({ path, value, typeSchema, fieldSchema, target })
+  const parsedValue = shared(path, value, fieldSchema)
+  if (!noCollect) {
+    handlers.collect({
+      path,
+      value: parsedValue,
+      typeSchema,
+      fieldSchema,
+      target,
+    })
+  }
 }

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

package/src/set/rest.ts

@@ -25,14 +25,15 @@ export const boolean: Parser<'boolean'> = async (
   fieldSchema,
   typeSchema,
   target,
-  handlers
+  handlers,
+  noCollect
 ) => {
-  // value .default
-  // $increment / $decrement
   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,12 +42,15 @@ 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 })
+      if (!noCollect) {
+        handlers.collect({ path, value: i, typeSchema, fieldSchema, target })
+      }
       return
     }
   }
@@ -59,17 +63,20 @@ export const json: Parser<'json'> = async (
   fieldSchema,
   typeSchema,
   target,
-  handlers
+  handlers,
+  noCollect
 ) => {
   try {
     const parsedValue = JSON.stringify(value)
-    handlers.collect({
-      path,
-      value: parsedValue,
-      typeSchema,
-      fieldSchema,
-      target,
-    })
+    if (!noCollect) {
+      handlers.collect({
+        path,
+        value: parsedValue,
+        typeSchema,
+        fieldSchema,
+        target,
+      })
+    }
   } catch (err) {
     throw err(path, ParseError.incorrectFormat)
   }

package/src/set/string.ts

@@ -101,10 +101,13 @@ export const string: Parser<'string'> = async (
   fieldSchema,
   typeSchema,
   target,
-  handlers
+  handlers,
+  noCollect
 ) => {
   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 +116,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
   }
 
@@ -135,25 +141,44 @@ export const text: Parser<'text'> = async (
   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 (value[key].$default) {
+      // }
+
+      if (!noCollect) {
+        handlers.collect({
+          path: newPath,
+          value: null,
+          typeSchema,
+          fieldSchema,
+          target,
+        })
+      }
+      continue
+    }
+
+    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,7 +11,8 @@ export type Parser<K extends keyof BasedSchemaFields> = (
   fieldSchema: BasedSchemaFields[K],
   typeSchema: BasedSchemaType,
   target: BasedSetTarget,
-  handlers: BasedSetHandlers
+  handlers: BasedSetHandlers,
+  noCollect?: boolean
 ) => Promise<void>
 
 export type Parsers = {

package/test/setWalker.ts

@@ -9,6 +9,9 @@ const schema: BasedSchema = {
         visits: {
           type: 'cardinality',
         },
+        blub: {
+          type: 'number',
+        },
         snurp: {
           type: 'array',
           values: {
@@ -149,6 +152,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,6 +209,7 @@ test.serial('collect correctly', async (t) => {
 
   const result = [
     { path: ['visits'], value: '3a9009740ee' },
+    { path: ['blub'], value: { $increment: 1 } },
     { path: ['bla'], value: false },
     { path: ['time'], value: now },
     { path: ['form', 'lastName'], value: 'de beer' },

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"}