@based/schema 0.0.15 → 1.0.1

package/src/set/collections.ts

@@ -1,338 +0,0 @@
-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,
-  fieldSchema,
-  typeSchema,
-  target,
-  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++) {
-      q.push(
-        fieldWalker([...path, i], value[i], fieldDef, typeSchema, target, {
-          ...handlers,
-          collect: ({ value }) => {
-            parsedArray.push(value)
-          },
-        })
-      )
-    }
-    await Promise.all(q)
-    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,
-            value.$add[i],
-            fieldDef,
-            typeSchema,
-            target,
-            handlers,
-            true
-          )
-        )
-      }
-    }
-    if (value.$remove) {
-      for (let i = 0; i < value.$remove.length; i++) {
-        q.push(
-          fieldWalker(
-            path,
-            value.$remove[i],
-            fieldDef,
-            typeSchema,
-            target,
-            handlers,
-            true
-          )
-        )
-      }
-    }
-    await Promise.all(q)
-    if (!noCollect) {
-      handlers.collect({ path, value, typeSchema, fieldSchema, target })
-    }
-  }
-}
-
-export const object: Parser<'object'> = async (
-  path,
-  value,
-  fieldSchema,
-  typeSchema,
-  target,
-  handlers,
-  noCollect
-) => {
-  if (typeof value !== 'object') {
-    error(handlers, ParseError.incorrectFormat, path)
-    return
-  }
-  const isArray = Array.isArray(value)
-  if (isArray) {
-    error(handlers, ParseError.incorrectFormat, path)
-    return
-  }
-  const q: Promise<void>[] = []
-  for (const key in value) {
-    const propDef = fieldSchema.properties[key]
-    if (!propDef) {
-      error(handlers, ParseError.fieldDoesNotExist, [...path, key])
-      continue
-    }
-    q.push(
-      fieldWalker(
-        [...path, key],
-        value[key],
-        propDef,
-        typeSchema,
-        target,
-        handlers,
-        noCollect
-      )
-    )
-  }
-  await Promise.all(q)
-  if (fieldSchema.required) {
-    for (const req of fieldSchema.required) {
-      if (!(req in value)) {
-        target.required.push([...path, req])
-      }
-    }
-  }
-}
-
-// 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,
-  fieldSchema,
-  typeSchema,
-  target,
-  handlers,
-  noCollect
-) => {
-  let isArray = Array.isArray(value)
-  let parsedValue = value
-  let opCount = 0
-  let has$Value = false
-  if (typeof parsedValue === 'object' && !isArray) {
-    if (value.$value) {
-      opCount++
-      has$Value = true
-      parsedValue = value.$value
-      isArray = Array.isArray(parsedValue)
-    }
-    if (value.$insert) {
-      opCount++
-      if (opCount > 1) {
-        error(handlers, ParseError.multipleOperationsNotAllowed, path)
-        return
-      }
-      if (
-        typeof value.$insert !== 'object' ||
-        value.$insert.$idx === undefined
-      ) {
-        error(handlers, ParseError.incorrectFormat, path)
-        return
-      } else {
-        const insert = Array.isArray(value.$insert.$value)
-          ? value.$insert.$value
-          : [value.$insert.$value]
-        const q: Promise<void>[] = []
-        for (let i = 0; i < insert.length; i++) {
-          q.push(
-            fieldWalker(
-              path,
-              insert[i],
-              fieldSchema.values,
-              typeSchema,
-              target,
-              handlers,
-              true
-            )
-          )
-        }
-        await Promise.all(q)
-      }
-    }
-    if (value.$remove) {
-      opCount++
-      if (opCount > 1) {
-        error(handlers, ParseError.multipleOperationsNotAllowed, path)
-        return
-      }
-      if (value.$remove.$idx === undefined) {
-        error(handlers, ParseError.incorrectFormat, path)
-        return
-      }
-    }
-    if (value.$push) {
-      opCount++
-      if (opCount > 1) {
-        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(
-            // exception
-            [...path, '$push', i],
-            push[i],
-            fieldSchema.values,
-            typeSchema,
-            target,
-            handlers,
-            true
-          )
-        )
-      }
-      await Promise.all(q)
-      parsedValue = { $push: push }
-    }
-    if (value.$unshift) {
-      opCount++
-      if (opCount > 1) {
-        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(
-            // exception
-            [...path, '$unshift', i],
-            unshift[i],
-            fieldSchema.values,
-            typeSchema,
-            target,
-            handlers,
-            true
-          )
-        )
-      }
-      await Promise.all(q)
-      parsedValue = { $unshift: unshift }
-    }
-    if (value.$assign) {
-      opCount++
-      if (opCount > 1) {
-        error(handlers, ParseError.multipleOperationsNotAllowed, path)
-        return
-      }
-      if (
-        typeof value.$assign !== 'object' ||
-        typeof value.$assign.$idx !== 'number'
-      ) {
-        error(handlers, ParseError.incorrectFormat, path)
-        return
-      }
-      await fieldWalker(
-        [...path, value.$assign.$idx],
-        value.$assign.$value,
-        fieldSchema.values,
-        typeSchema,
-        target,
-        handlers,
-        noCollect
-      )
-      return
-    }
-    if (!has$Value && !noCollect) {
-      handlers.collect({
-        path,
-        value: parsedValue,
-        typeSchema,
-        fieldSchema,
-        target,
-      })
-    }
-    if (!has$Value) {
-      return
-    }
-  }
-  if (!isArray) {
-    error(handlers, ParseError.incorrectFieldType, path)
-    return
-  }
-  const q: Promise<void>[] = []
-  const collector: any[] = []
-  const nHandler = noCollect
-    ? handlers
-    : {
-        ...handlers,
-        collect: (collect) => {
-          collector.push(collect)
-        },
-      }
-  for (let i = 0; i < parsedValue.length; i++) {
-    q.push(
-      fieldWalker(
-        [...path, i],
-        parsedValue[i],
-        fieldSchema.values,
-        typeSchema,
-        target,
-        nHandler,
-        noCollect
-      )
-    )
-  }
-
-  await Promise.all(q)
-
-  if (!noCollect) {
-    handlers.collect({
-      path,
-      typeSchema,
-      fieldSchema,
-      target,
-      value: { $delete: true },
-    })
-    for (const c of collector) {
-      handlers.collect(c)
-    }
-  }
-}
-
-export const record: Parser<'record'> = async (path, value, fieldSchema) => {}

package/src/set/number.ts

@@ -1,167 +0,0 @@
-import { Parser } from './types'
-import { error, ParseError } from './error'
-import {
-  BasedSchemaFieldInteger,
-  BasedSchemaFieldNumber,
-  BasedSchemaFieldTimeStamp,
-  BasedSetHandlers,
-} from '../types'
-
-const validate = (
-  handlers: BasedSetHandlers,
-  path: (number | string)[],
-  value: any,
-  fieldSchema:
-    | BasedSchemaFieldInteger
-    | BasedSchemaFieldNumber
-    | BasedSchemaFieldTimeStamp
-): number | false => {
-  if (typeof value !== 'number') {
-    error(handlers, ParseError.incorrectFormat, path)
-    return false
-  }
-  if (fieldSchema.type === 'integer' && value - Math.floor(value) !== 0) {
-    error(handlers, ParseError.incorrectFormat, path)
-    return false
-  }
-  if (
-    fieldSchema.multipleOf &&
-    value / fieldSchema.multipleOf -
-      Math.floor(value / fieldSchema.multipleOf) !==
-      0
-  ) {
-    error(handlers, ParseError.incorrectFormat, path)
-    return false
-  }
-  if (fieldSchema.maximum) {
-    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) {
-      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:
-    | BasedSchemaFieldInteger
-    | BasedSchemaFieldNumber
-    | BasedSchemaFieldTimeStamp
-): any => {
-  if (typeof value === 'object') {
-    if (value.$increment) {
-      validate(handlers, [...path, '$increment'], value.$increment, fieldSchema)
-    }
-    if (value.$decrement) {
-      validate(handlers, [...path, '$decrement'], value.$decrement, fieldSchema)
-    }
-    if (value.$value !== undefined) {
-      validate(handlers, path, value.$value, fieldSchema)
-    }
-    if (value.$default !== undefined) {
-      if (value.$value !== undefined) {
-        error(handlers, ParseError.valueAndDefault, path)
-        return
-      }
-      validate(handlers, path, value.$default, fieldSchema)
-    }
-  } else {
-    validate(handlers, path, value, fieldSchema)
-  }
-  return value
-}
-
-export const timestamp: Parser<'timestamp'> = async (
-  path,
-  value,
-  fieldSchema,
-  typeSchema,
-  target,
-  handlers,
-  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(handlers, ParseError.incorrectFormat, path)
-        return
-      }
-    }
-  }
-  const parsedValue = shared(handlers, 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(handlers, 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
-) => {
-  const parsedValue = shared(handlers, path, value, fieldSchema)
-  if (!noCollect) {
-    handlers.collect({
-      path,
-      value: parsedValue,
-      typeSchema,
-      fieldSchema,
-      target,
-    })
-  }
-}

package/src/set/parseDefaultAndValue.ts

@@ -1,54 +0,0 @@
-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...
-      await parse(
-        path,
-        value.$value,
-        fieldSchema,
-        typeSchema,
-        target,
-        handlers,
-        true
-      )
-      handled = true
-    }
-    if (value.$default !== undefined) {
-      if (value.$value !== undefined) {
-        error(handlers, ParseError.valueAndDefault, path)
-      }
-      console.info('->', path, 'go')
-      await parse(
-        path,
-        value.$default,
-        fieldSchema,
-        typeSchema,
-        target,
-        handlers,
-        true
-      )
-      handled = true
-    }
-  }
-  if (handled && !noCollect) {
-    console.log('collect?')
-    handlers.collect({ path, value, typeSchema, fieldSchema, target })
-  }
-  return handled
-}

package/src/set/parsers.ts

@@ -1,20 +0,0 @@
-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

package/src/set/references.ts

@@ -1,113 +0,0 @@
-import { Parser } from './types'
-import { error, ParseError } from './error'
-
-export const reference: Parser<'reference'> = async (
-  path,
-  value,
-  fieldSchema,
-  typeSchema,
-  target,
-  handlers,
-  noCollect
-) => {
-  // $no root
-  // prob pass these as options
-  // value .default
-  // $value
-
-  if (typeof value !== 'string') {
-    error(handlers, ParseError.incorrectFormat, path)
-  }
-
-  if ('allowedTypes' in fieldSchema) {
-    const prefix = value.slice(0, 2)
-    const targetType = target.schema.prefixToTypeMapping[prefix]
-    if (!targetType) {
-      error(handlers, ParseError.referenceIsIncorrectType, path)
-      return
-    }
-    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))) {
-              error(handlers, ParseError.referenceIsIncorrectType, path)
-              return
-            }
-          }
-        } else if (!t.type && t.$filter) {
-          if (!(await handlers.referenceFilterCondition(value, t.$filter))) {
-            error(handlers, ParseError.referenceIsIncorrectType, path)
-            return
-          }
-        }
-      }
-    }
-    if (typeMatches === false) {
-      error(handlers, ParseError.referenceIsIncorrectType, path)
-      return
-    }
-  }
-  if (!noCollect) {
-    handlers.collect({ path, value, typeSchema, fieldSchema, target })
-  }
-}
-
-export const references: Parser<'references'> = async (
-  path,
-  value,
-  fieldSchema,
-  typeSchema,
-  target,
-  handlers,
-  noCollect
-) => {
-  // default
-  // $no root
-  if (Array.isArray(value)) {
-    await Promise.all(
-      value.map((v, i) => {
-        return reference(
-          [...path, i],
-          v,
-          // not nice slow
-          { ...fieldSchema, type: 'reference' },
-          typeSchema,
-          target,
-          handlers,
-          true
-        )
-      })
-    )
-    value = { $value: value }
-  } else if (typeof value === 'object') {
-    if (value.$add) {
-      await Promise.all(
-        value.$add.map((v, i) => {
-          return reference(
-            [...path, '$add', i],
-            v,
-            // not nice slow
-            { ...fieldSchema, type: 'reference' },
-            typeSchema,
-            target,
-            handlers,
-            true
-          )
-        })
-      )
-    }
-  } else {
-    error(handlers, ParseError.incorrectFormat, path)
-  }
-  if (!noCollect) {
-    handlers.collect({ path, value, typeSchema, fieldSchema, target })
-  }
-}