@based/schema 0.0.1

package/src/set/index.ts

@@ -0,0 +1,135 @@
+import {
+  BasedSchemaField,
+  BasedSchemaType,
+  BasedSetHandlers,
+  BasedSchema,
+  BasedSetTarget,
+} from '../types'
+import { createError } from './handleError'
+import parsers from './parsers'
+
+// Collect is a pretty good place for checking if a user is allowed to set something
+// also make collect async
+
+// add extra function for loading required
+
+export const fieldWalker = async (
+  path: (string | number)[],
+  value: any,
+  fieldSchema: BasedSchemaField,
+  typeSchema: BasedSchemaType,
+  target: BasedSetTarget,
+  handlers: BasedSetHandlers
+): 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
+    return
+  }
+  const valueType = typeof value
+
+  const valueIsObject = value && valueType === 'object'
+  if (valueIsObject && value.$delete === true) {
+    handlers.collect({ path, value, typeSchema, fieldSchema, target })
+    return
+  }
+
+  const typeDef =
+    'type' in fieldSchema
+      ? fieldSchema.type
+      : 'enum' in fieldSchema
+      ? 'enum'
+      : ''
+
+  if (!typeDef) {
+    throw createError(path, target.type, typeDef, path[path.length - 1])
+  }
+
+  if ('customValidator' in fieldSchema) {
+    const customValidator = fieldSchema.customValidator
+    if (!(await customValidator(value, path, target))) {
+      throw createError(path, target.type, typeDef, value)
+    }
+  }
+
+  const parse = parsers[typeDef]
+
+  await parse(path, value, fieldSchema, typeSchema, target, handlers)
+
+  return
+}
+
+export const setWalker = async (
+  schema: BasedSchema,
+  value: { [key: string]: any },
+  handlers: BasedSetHandlers
+): Promise<BasedSetTarget> => {
+  let type: string
+
+  if (value.$id) {
+    type = schema.prefixToTypeMapping[value.$id.slice(0, 2)]
+    if (!type) {
+      throw new Error(`Cannot find type for $id ${value.$id}`)
+    }
+  }
+
+  if (value.type) {
+    if (type && value.type !== type) {
+      throw new Error(
+        `type from "$id" ${value.$id} does not match "type" field ${value.type}`
+      )
+    }
+    type = value.type
+  }
+
+  const schemaType = schema.types[type]
+
+  if (!schemaType) {
+    throw new Error(`Cannot find schema definition for type ${type}`)
+  }
+
+  const target: BasedSetTarget = {
+    type,
+    schema,
+  }
+
+  if (value.$id) {
+    target.$id = value.$id
+  } else if (value.$alias) {
+    target.$alias = value.$alias
+  }
+
+  const q: Promise<void>[] = []
+
+  for (const key in value) {
+    if (key[0] === '$') {
+      console.info('key is operator', key)
+    } else {
+      const fieldSchema = schemaType.fields[key]
+      if (!fieldSchema) {
+        throw new Error(
+          `Field does not exist in schema "${key}" on type "${type}"`
+        )
+      } else {
+        q.push(
+          fieldWalker(
+            [key],
+            value[key],
+            fieldSchema,
+            schemaType,
+            target,
+            handlers
+          )
+        )
+      }
+    }
+  }
+
+  await Promise.all(q)
+
+  // required fields (collect them!)
+  //   if (!(await handlers.requiredFields(value, [], target))) {
+  //     throw new Error('Missing required fields')
+  //   }
+
+  return target
+}

package/src/set/parsers.ts

@@ -0,0 +1,448 @@
+import {
+  BasedSchemaField,
+  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: 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)
+    }
+  },
+
+  number: async (path, value, fieldSchema, typeSchema, target, handlers) => {
+    // value .default
+    // $increment / $decrement
+
+    if (typeof value !== 'number') {
+      throw createError(path, target.type, 'number', value)
+    }
+    handlers.collect({ path, value, typeSchema, fieldSchema, target })
+  },
+
+  integer: async (path, value, fieldSchema, typeSchema, target, handlers) => {
+    // value .default
+    // $increment / $decrement
+
+    if (typeof value !== 'number' || value - Math.floor(value) !== 0) {
+      throw createError(path, target.type, 'integer', 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
+          )
+        })
+      )
+    } 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 })
+  },
+}
+
+export default parsers