@based/schema 0.0.5 → 0.0.7

package/src/set/number.ts

@@ -0,0 +1,136 @@
+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,
+  value,
+  fieldSchema,
+  typeSchema,
+  target,
+  handlers,
+  noCollect
+) => {
+  if (typeof value === 'string') {
+    if (value === 'now') {
+      value = Date.now()
+    } else {
+      const d = new Date(value)
+      value = d.valueOf()
+      if (isNaN(value)) {
+        throw error(path, ParseError.incorrectFormat)
+      }
+    }
+  }
+  const parsedValue = shared(path, value, fieldSchema)
+  if (!noCollect) {
+    handlers.collect({
+      path,
+      value: parsedValue,
+      typeSchema,
+      fieldSchema,
+      target,
+    })
+  }
+}
+
+export const number: Parser<'number'> = async (
+  path,
+  value,
+  fieldSchema,
+  typeSchema,
+  target,
+  handlers,
+  noCollect
+) => {
+  const parsedValue = shared(path, value, fieldSchema)
+  if (!noCollect) {
+    handlers.collect({
+      path,
+      value: parsedValue,
+      typeSchema,
+      fieldSchema,
+      target,
+    })
+  }
+}
+
+export const integer: Parser<'integer'> = async (
+  path,
+  value,
+  fieldSchema,
+  typeSchema,
+  target,
+  handlers,
+  noCollect
+) => {
+  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,
+    })
+  }
+}

package/src/set/parsers.ts

@@ -1,556 +1,20 @@
-import {
-  BasedSchemaField,
-  BasedSchemaFieldInteger,
-  BasedSchemaFieldNumber,
-  BasedSchemaFieldTimeStamp,
-  BasedSchemaType,
-  BasedSetHandlers,
-  BasedSetTarget,
-} from '../types'
-import { deepEqual } from '@saulx/utils'
-import { createError } from './handleError'
-import { fieldWalker } from '.'
-
-type Parser = (
-  path: (string | number)[],
-  value: any,
-  fieldSchema: BasedSchemaField,
-  typeSchema: BasedSchemaType,
-  target: BasedSetTarget,
-  handlers: BasedSetHandlers
-) => Promise<void>
-
-const reference: Parser = async (
-  path,
-  value,
-  fieldSchema,
-  typeSchema,
-  target,
-  handlers
-) => {
-  // $no root
-
-  // prob pass these as options
-  // value .default
-  // $value
-
-  if (typeof value !== 'string') {
-    throw createError(path, target.type, 'reference', value)
-  }
-  if ('allowedTypes' in fieldSchema) {
-    const prefix = value.slice(0, 2)
-    const targetType = target.schema.prefixToTypeMapping[prefix]
-    if (!targetType) {
-      throw createError(
-        path,
-        target.type,
-        'reference',
-        value,
-        '',
-        `${prefix} does not exist in database`
-      )
-    }
-    let typeMatches = false
-    for (const t of fieldSchema.allowedTypes) {
-      if (typeof t === 'string') {
-        if (t === targetType) {
-          typeMatches = true
-          break
-        }
-      } else {
-        if (t.type && t.type === targetType) {
-          typeMatches = true
-          if (t.$filter) {
-            if (!(await handlers.referenceFilterCondition(value, t.$filter))) {
-              throw createError(
-                path,
-                target.type,
-                'reference',
-                value,
-                '',
-                `${targetType} does not match allowedReferences`
-              )
-            }
-          }
-        } else if (!t.type && t.$filter) {
-          if (!(await handlers.referenceFilterCondition(value, t.$filter))) {
-            throw createError(
-              path,
-              target.type,
-              'reference',
-              value,
-              '',
-              `${targetType} does not match allowedReferences`
-            )
-          }
-        }
-      }
-    }
-    if (typeMatches === false) {
-      throw createError(
-        path,
-        target.type,
-        'reference',
-        value,
-        '',
-        `${targetType} does not match allowedReferences`
-      )
-    }
-  }
-  handlers.collect({ path, value, typeSchema, fieldSchema, target })
-}
-
-const parsers: {
-  [key: string]: Parser
-} = {
-  enum: async (path, value, fieldSchema, typeSchema, target, handlers) => {
-    // value .default
-
-    // @ts-ignore
-    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
-      }
-    }
-    throw createError(path, target.type, 'enum', value)
-  },
-
-  array: async (path, value, fieldSchema, typeSchema, target, handlers) => {
-    // value .default
-
-    // TODO: ADD ARRAY OPERATORS
-    const isArray = Array.isArray(value)
-
-    if (typeof value === 'object' && !isArray) {
-      const q: Promise<void>[] = []
-
-      if (value.$insert) {
-      }
-
-      if (value.$remove) {
-      }
-
-      if (value.$push) {
-      }
-
-      if (value.$assign) {
-      }
-
-      // value.$value :/
-      // fix
-      handlers.collect({ path, value, typeSchema, fieldSchema, target })
-
-      return
-    }
-
-    if (!isArray) {
-      throw createError(path, target.type, 'array', value)
-    }
-    const q: Promise<void>[] = []
-    for (let i = 0; i < value.length; i++) {
-      q.push(
-        fieldWalker(
-          [...path, i],
-          value[i],
-          // @ts-ignore
-          fieldSchema.values,
-          typeSchema,
-          target,
-          handlers
-        )
-      )
-    }
-    await Promise.all(q)
-  },
-
-  object: async (path, value, fieldSchema, typeSchema, target, handlers) => {
-    // value .default
-
-    if (typeof value !== 'object') {
-      throw createError(path, target.type, 'object', value)
-    }
-    const isArray = Array.isArray(value)
-    if (isArray) {
-      throw createError(path, target.type, 'object', value)
-    }
-    const q: Promise<void>[] = []
-    for (const key in value) {
-      // @ts-ignore
-      const propDef = fieldSchema.properties[key]
-      if (!propDef) {
-        throw createError(
-          [...path, key],
-          target.type,
-          'object',
-          value[key],
-          key
-        )
-      }
-      q.push(
-        fieldWalker(
-          [...path, key],
-          value[key],
-          propDef,
-          typeSchema,
-          target,
-          handlers
-        )
-      )
-    }
-    await Promise.all(q)
-  },
-
-  set: async (path, value, fieldSchema, typeSchema, target, handlers) => {
-    // value .default
-
-    const q: Promise<void>[] = []
-    //   @ts-ignore
-    const fieldDef = fieldSchema.items
-
-    if (Array.isArray(value)) {
-      const handlerNest = {
-        ...handlers,
-        collect: ({ path, 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
-          )
-        )
-      }
-      await Promise.all(q)
-      handlers.collect({
-        path,
-        value: { $value: parsedArray },
-        typeSchema,
-        fieldSchema,
-        target,
-      })
-    } else {
-      const handlerNest = {
-        ...handlers,
-        collect: ({ path, value }) => {},
-      }
-      if (value.$add) {
-        for (let i = 0; i < value.$add.length; i++) {
-          q.push(
-            fieldWalker(
-              [...path, '$add', i],
-              value.$add[i],
-              fieldDef,
-              typeSchema,
-              target,
-              handlerNest
-            )
-          )
-        }
-      }
-      if (value.$delete) {
-        for (let i = 0; i < value.$add.length; i++) {
-          q.push(
-            fieldWalker(
-              [...path, '$delete', i],
-              value.$delete[i],
-              fieldDef,
-              typeSchema,
-              target,
-              handlerNest
-            )
-          )
-        }
-      }
-      await Promise.all(q)
-      handlers.collect({ path, value, typeSchema, fieldSchema, target })
-    }
-  },
-
-  json: async (path, value, fieldSchema, typeSchema, target, handlers) => {
-    // value .default
-
-    try {
-      const parsedValue = JSON.stringify(value)
-      handlers.collect({
-        path,
-        value: parsedValue,
-        typeSchema,
-        fieldSchema,
-        target,
-      })
-    } catch (err) {
-      throw createError(path, target.type, 'json', value)
-    }
-  },
-
-  boolean: async (path, value, fieldSchema, typeSchema, target, handlers) => {
-    // value .default
-    // $increment / $decrement
-
-    if (typeof value !== 'boolean') {
-      throw createError(path, target.type, 'boolean', value)
-    }
-    handlers.collect({ path, value, typeSchema, fieldSchema, target })
-  },
-
-  timestamp: async (
-    path,
-    value,
-    fieldSchema: BasedSchemaFieldTimeStamp,
-    typeSchema,
-    target,
-    handlers
-  ) => {
-    if (typeof value === 'string') {
-      if (value === 'now') {
-        value = Date.now()
-      } else {
-        const d = new Date(value)
-        value = d.valueOf()
-        if (isNaN(value)) {
-          throw createError(path, target.type, 'timestamp', value)
-        }
-      }
-    }
-
-    // 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 })
-  },
-
-  number: async (
-    path,
-    value,
-    fieldSchema: BasedSchemaFieldNumber,
-    typeSchema,
-    target,
-    handlers
-  ) => {
-    // value .default
-    // $increment / $decrement
-
-    if (typeof value !== 'number') {
-      throw createError(path, target.type, 'number', value)
-    }
-
-    if (fieldSchema.maximum) {
-      if (fieldSchema.exclusiveMaximum && value > value) {
-        throw createError(path, target.type, 'number', value)
-      } else if (value >= value) {
-        throw createError(path, target.type, 'number', value)
-      }
-    }
-
-    if (fieldSchema.minimum) {
-      if (fieldSchema.exclusiveMinimum && value < value) {
-        throw createError(path, target.type, 'number', value)
-      } else if (value <= value) {
-        throw createError(path, target.type, 'number', value)
-      }
-    }
-
-    handlers.collect({ path, value, typeSchema, fieldSchema, target })
-  },
-
-  integer: async (
-    path,
-    value,
-    fieldSchema: BasedSchemaFieldInteger,
-    typeSchema,
-    target,
-    handlers
-  ) => {
-    // value .default
-    // $increment / $decrement
-
-    // smaller then / larger then steps
-
-    if (typeof value !== 'number' || value - Math.floor(value) !== 0) {
-      throw createError(path, target.type, 'integer', value)
-    }
-
-    if (fieldSchema.maximum) {
-      if (fieldSchema.exclusiveMaximum && value > value) {
-        throw createError(path, target.type, 'number', value)
-      } else if (value >= value) {
-        throw createError(path, target.type, 'number', value)
-      }
-    }
-
-    if (fieldSchema.minimum) {
-      if (fieldSchema.exclusiveMinimum && value < value) {
-        throw createError(path, target.type, 'number', value)
-      } else if (value <= value) {
-        throw createError(path, target.type, 'number', value)
-      }
-    }
-
-    handlers.collect({ path, value, typeSchema, fieldSchema, target })
-  },
-
-  string: async (path, value, fieldSchema, typeSchema, target, handlers) => {
-    // default
-
-    if (typeof value !== 'string') {
-      throw createError(path, target.type, 'string', value)
-    }
-    // @ts-ignore
-    if (fieldSchema.minLength && value.length < fieldSchema.minLength) {
-      throw createError(path, target.type, 'string', value)
-    }
-    // @ts-ignore
-    if (fieldSchema.maxLength && value.length > fieldSchema.maxLength) {
-      throw createError(path, target.type, 'string', value)
-    }
-    handlers.collect({ path, value, typeSchema, fieldSchema, target })
-  },
-
-  text: async (path, value, fieldSchema, typeSchema, target, handlers) => {
-    // default
-
-    const valueType = typeof value
-    if (target.$language && valueType === 'string') {
-      // @ts-ignore
-      if (fieldSchema.minLength && value.length < fieldSchema.minLength) {
-        throw createError(path, target.type, 'text', value)
-      }
-      // @ts-ignore
-      if (fieldSchema.maxLength && value.length > fieldSchema.maxLength) {
-        throw createError(path, target.type, 'text', value)
-      }
-
-      handlers.collect({
-        path,
-        value: { [target.$language]: value },
-        typeSchema,
-        fieldSchema,
-        target,
-      })
-      return
-    }
-
-    if (valueType !== 'object') {
-      throw createError(path, target.type, 'text', value)
-    }
-
-    for (const key in value) {
-      // @ts-ignore
-      if (fieldSchema.minLength && value[key].length < fieldSchema.minLength) {
-        throw createError([...path, key], target.type, 'text', value)
-      }
-
-      // @ts-ignore
-      if (fieldSchema.maxLength && value[key].length > fieldSchema.maxLength) {
-        throw createError([...path, key], target.type, 'text', value)
-      }
-
-      if (typeof value[key] === 'object' && value[key].$delete === true) {
-        handlers.collect({
-          path: [...path, key],
-          value: null,
-          typeSchema,
-          fieldSchema,
-          target,
-        })
-        continue
-      }
-
-      if (typeof value[key] !== 'string') {
-        throw createError([...path, key], target.type, 'text', value)
-      }
-
-      handlers.collect({
-        path: [...path, key],
-        value: value[key],
-        typeSchema,
-        fieldSchema,
-        target,
-      })
-    }
-  },
-
-  reference,
-
-  references: async (
-    path,
-    value,
-    fieldSchema,
-    typeSchema,
-    target,
-    handlers
-  ) => {
-    // default
-    // $no root
-
-    if (Array.isArray(value)) {
-      const handler = {
-        ...handlers,
-        collect: () => {},
-      }
-      await Promise.all(
-        value.map((v, i) => {
-          return reference(
-            [...path, i],
-            v,
-            fieldSchema,
-            typeSchema,
-            target,
-            handler
-          )
-        })
-      )
-      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(
-              [...path, '$add', i],
-              v,
-              fieldSchema,
-              typeSchema,
-              target,
-              handler
-            )
-          })
-        )
-      }
-    }
-
-    handlers.collect({ path, value, typeSchema, fieldSchema, target })
-  },
+import { Parsers } from './types'
+import * as references from './references'
+import * as collections from './collections'
+import * as number from './number'
+import * as string from './string'
+
+import { enumParser, boolean, cardinality, json } from './rest'
+
+const parsers: Parsers = {
+  ...string,
+  ...references,
+  ...collections,
+  ...number,
+  enum: enumParser,
+  boolean,
+  cardinality,
+  json,
 }
 
 export default parsers