@based/schema 0.0.16 → 1.0.2

package/src/set/index.ts

@@ -1,197 +1,115 @@
-import {
-  BasedSchemaField,
-  BasedSchemaType,
-  BasedSetHandlers,
-  BasedSchema,
-  BasedSetTarget,
-  BasedSchemaCollectProps,
-  BasedSetOptionalHandlers,
-} from '../types'
-import { error, ParseError } from './error'
-import parsers from './parsers'
-import { SetOptional } from 'type-fest'
-
-export const fieldWalker = async (
-  path: (string | number)[],
-  value: any,
-  fieldSchema: BasedSchemaField,
-  typeSchema: BasedSchemaType,
-  target: BasedSetTarget,
-  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
-    return
-  }
-  const valueType = typeof value
-
-  const valueIsObject = value && valueType === 'object'
-  if (valueIsObject && value.$delete === true) {
-    if (!noCollect) {
-      handlers.collect({ path, value, typeSchema, fieldSchema, target })
-    }
-    return
-  }
-
-  const typeDef = fieldSchema.type ?? ('enum' in fieldSchema ? 'enum' : '')
-
-  if (!typeDef) {
-    error(handlers, ParseError.fieldDoesNotExist, path)
-  }
-
-  if ('customValidator' in fieldSchema) {
-    const customValidator = fieldSchema.customValidator
-    if (!(await customValidator(value, path, target))) {
-      error(handlers, ParseError.incorrectFormat, path)
-    }
-  }
-
-  const parse = parsers[typeDef]
-
-  await parse(path, value, fieldSchema, typeSchema, target, handlers, noCollect)
-
-  return
-}
-
-export const setWalker = async (
-  schema: BasedSchema,
-  value: { [key: string]: any },
-  inHandlers: BasedSetOptionalHandlers
-): Promise<BasedSetTarget> => {
-  let errors: {
-    message: string
-    code: ParseError
-  }[]
-
-  const collect: BasedSchemaCollectProps[] = []
-
-  const x = { ...inHandlers }
-
-  if (!('collectErrors' in x)) {
-    errors = []
-    x.collectErrors = (info) => {
-      errors.push(info)
-    }
-  }
-
-  let prevCollect: any
-
-  if (!('collect' in x)) {
-    x.collect = (info) => {
-      collect.push(info)
-    }
-  } else {
-    prevCollect = x.collect
-    x.collect = (info) => {
-      collect.push(info)
-    }
-  }
-
-  const handlers: BasedSetHandlers = <BasedSetHandlers>x
-
-  let type: string
-
-  if (value.$id) {
-    type = schema.prefixToTypeMapping[value.$id.slice(0, 2)]
-    if (!type) {
-      error(handlers, ParseError.incorrectNodeType, [value.$id])
-    }
-  }
-
-  if (value.type) {
-    if (type && value.type !== type) {
-      error(handlers, ParseError.incorrectNodeType, [value.$id, value.type])
-    }
-    type = value.type
-  }
-
-  const schemaType = schema.types[type]
-
-  if (!schemaType) {
-    error(handlers, ParseError.incorrectNodeType, [type])
-  }
-
-  const target: BasedSetTarget = {
-    type,
-    schema,
-    required: [],
-  }
-
-  if (value.$language) {
-    if (!schema.languages.includes(value.$language)) {
-      error(handlers, ParseError.languageNotSupported, ['$language'])
+import { ParseError } from '../error'
+import { BasedSchema, BasedSetTarget } from '../types'
+import { walk, Opts } from '../walker'
+import { fields } from './fields'
+import { isValidId } from './isValidId'
+
+const opts: Opts<BasedSetTarget> = {
+  parsers: {
+    keys: {
+      $id: async (args) => {
+        if (!isValidId(args.schema, args.value)) {
+          args.error(ParseError.incorrectFormat)
+          return
+        }
+      },
+      $language: async (args) => {
+        if (!args.schema.languages.includes(args.value)) {
+          args.error(ParseError.languageNotSupported)
+          return
+        }
+      },
+      $value: async (args) => {
+        const type = args.fieldSchema?.type
+        if (type === 'text') {
+          return
+        }
+        args.stop()
+        if (args.prev.value.$default) {
+          args.error(ParseError.valueAndDefault)
+          return
+        }
+        return { path: args.path.slice(0, -1) }
+      },
+      $default: async (args) => {
+        const type = args.fieldSchema?.type
+        if (type === 'number' || type === 'integer' || type === 'text') {
+          // default can exist with $incr and $decr
+          return
+        }
+        args.prev.stop()
+        const newArgs = args.create({
+          path: args.path.slice(0, -1),
+          skipCollection: true,
+        })
+        await newArgs.parse()
+        for (const key in args.prev.value) {
+          if (key !== '$default') {
+            args.prev.create({ key }).error(ParseError.fieldDoesNotExist)
+          }
+        }
+        newArgs.skipCollection = false
+        newArgs.value = { $default: newArgs.value }
+        newArgs.collect()
+      },
+    },
+    fields,
+    catch: async (args) => {
+      args.error(ParseError.fieldDoesNotExist)
+    },
+  },
+  init: async (value, schema, error) => {
+    let type: string
+    const target: BasedSetTarget = {
+      type,
+      schema,
+      required: [],
+      collected: [],
+      errors: [],
     }
-    target.$language = value.$language
-  }
-
-  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] !== '$' && key !== 'type') {
-      const fieldSchema = schemaType.fields[key]
-      if (!fieldSchema) {
-        error(handlers, ParseError.fieldDoesNotExist, [key])
+    if (value.$id) {
+      if (value.$id === 'root') {
+        type = 'root'
       } else {
-        q.push(
-          fieldWalker(
-            [key],
-            value[key],
-            fieldSchema,
-            schemaType,
-            target,
-            handlers
-          )
-        )
+        type = schema.prefixToTypeMapping[value.$id.slice(0, 2)]
       }
-    }
-  }
-
-  await Promise.all(q)
-
-  if (schemaType.required) {
-    for (const req of schemaType.required) {
-      if (!(req in value)) {
-        target.required.push([req])
+      if (!type) {
+        error(ParseError.incorrectFieldType, { target })
+        return
       }
+    } else if (value.$alias) {
+      target.$alias = value.$alias
     }
-  }
 
-  if (target.required?.length) {
-    const requireDefined = await Promise.all(
-      target.required.map(async (req) => {
-        return handlers.checkRequiredFields(req)
-      })
-    )
-    for (let i = 0; i < requireDefined.length; i++) {
-      if (!requireDefined[i]) {
-        const r = target.required[i]
-        error(handlers, ParseError.requiredFieldNotDefined, r)
+    if (value.type) {
+      if (type && value.type !== type) {
+        error(ParseError.incorrectNodeType, { target })
+        return
       }
+      type = value.type
     }
-  }
-
-  if (errors?.length) {
-    const err = new Error(
-      'Errors in in set' +
-        errors.reduce((str, info) => {
-          return str + `\n - ${info.message}`
-        }, '')
-    )
-    throw err
-  }
-
-  if (prevCollect) {
-    for (const x of collect) {
-      prevCollect(x)
+    const typeSchema = type === 'root' ? schema.root : schema.types[type]
+    if (!typeSchema) {
+      error(ParseError.incorrectNodeType, { target })
+      return
     }
-  }
-
-  return target
+    target.type = type
+    target.$language = value.$language
+    target.$id = value.$id
+    return { target, typeSchema }
+  },
+  error: (code, args) => {
+    args.target.errors.push({
+      code,
+      path: args.path ?? [],
+    })
+  },
+  collect: (args) => {
+    args.root.target.collected.push(args)
+  },
 }
+
+export const setWalker = (
+  schema: BasedSchema,
+  value: any
+): Promise<BasedSetTarget> => walk<BasedSetTarget>(schema, opts, value)

package/src/set/isValidId.ts

@@ -0,0 +1,23 @@
+import { BasedSchema } from '../types'
+
+export const isValidId = (schema: BasedSchema, id: any): boolean => {
+  if (typeof id !== 'string') {
+    return false
+  }
+
+  if (id === 'root') {
+    return true
+  }
+
+  if (id.length > 10) {
+    return false
+  }
+
+  const prefix = id.slice(0, 2)
+
+  if (!schema.prefixToTypeMapping[prefix]) {
+    return false
+  }
+
+  return true
+}

package/src/set/types.ts

@@ -1,20 +0,0 @@
-import {
-  BasedSchemaType,
-  BasedSetHandlers,
-  BasedSetTarget,
-  BasedSchemaFields,
-} from '../types'
-
-export type Parser<K extends keyof BasedSchemaFields> = (
-  path: (string | number)[],
-  value: any,
-  fieldSchema: BasedSchemaFields[K],
-  typeSchema: BasedSchemaType,
-  target: BasedSetTarget,
-  handlers: BasedSetHandlers,
-  noCollect?: boolean
-) => Promise<void | boolean>
-
-export type Parsers = {
-  [Key in keyof BasedSchemaFields]: Parser<Key>
-}

package/src/types.ts

@@ -1,6 +1,7 @@
 import type { Language } from './languages'
 import type { PartialDeep, SetOptional } from 'type-fest'
-import { ParseError } from './set/error'
+import { ParseError } from './error'
+import { ArgsClass, Path } from './walker'
 
 // Schema type
 // inspiration from https://json-schema.org/understanding-json-schema/index.html
@@ -65,7 +66,6 @@ export type BasedSchemaFieldShared = {
   hooks?:
     | { interval?: number; hook: string }
     | { interval?: number; hook: string }[]
-
   type?: BasedSchemaFieldType
   $id?: string
   $schema?: string
@@ -345,6 +345,8 @@ export type BasedSetTarget = {
   schema: BasedSchema
   $language?: BasedSchemaLanguage
   required: (number | string)[][]
+  collected: ArgsClass<BasedSetTarget>[]
+  errors: { code: ParseError; path: Path }[]
 }
 
 export type BasedSchemaCollectProps = {

package/src/walker/args.ts

@@ -0,0 +1,159 @@
+import { BasedSchema } from '../types'
+import { BasedSchemaType, BasedSchemaFields } from '../types'
+import { ArgsOpts, Path, Opts, Stopped, ErrorHandler, Collect } from './types'
+import { parse } from './parse'
+import { ParseError } from '../error'
+
+export class ArgsClass<
+  T,
+  K extends keyof BasedSchemaFields = keyof BasedSchemaFields
+> {
+  errors: any[]
+
+  prev: ArgsClass<T, K>
+
+  root: ArgsClass<T, K> // getter
+
+  // only on root
+  _opts: Opts<T>
+
+  _target: T
+
+  _schema: BasedSchema
+
+  parseTopLevel?: boolean
+
+  _collectOverride: Collect<T>
+
+  fieldSchema?: BasedSchemaFields[K]
+
+  typeSchema?: BasedSchemaType
+
+  path: Path
+
+  skipCollection: boolean
+
+  value: any
+
+  stopped: Stopped | void
+
+  fromBackTrack: any[]
+
+  collectedCommands: any[]
+
+  constructor(opts: ArgsOpts<T, K>, prev?: ArgsClass<T, K>) {
+    this.fromBackTrack = []
+    this.collectedCommands = []
+    if (opts.prev) {
+      prev = opts.prev
+    }
+    if (opts.parseTopLevel) {
+      this.parseTopLevel = opts.parseTopLevel
+    }
+    if (prev) {
+      this.prev = prev
+      this.root = prev.root
+      this.fieldSchema = prev.fieldSchema
+    }
+    if (opts.path) {
+      this.path = opts.path
+    } else if (prev && opts.key !== undefined) {
+      this.path = [...prev.path, opts.key]
+    } else if (opts && prev) {
+      this.path = prev.path
+    } else {
+      this.path = []
+    }
+    this.value = opts.value
+    if (opts.fieldSchema) {
+      // @ts-ignore K is too loose
+      this.fieldSchema = opts.fieldSchema
+    }
+    if (opts.typeSchema) {
+      this.typeSchema = opts.typeSchema
+    }
+    if (opts.target) {
+      this._target = opts.target
+    }
+    if (opts.collect) {
+      this._collectOverride = opts.collect
+    }
+    if (opts.skipCollection) {
+      this.skipCollection = opts.skipCollection
+    }
+  }
+
+  get schema(): BasedSchema {
+    if (this._schema) {
+      return this.schema
+    }
+    return this.root._schema
+  }
+
+  get key(): (number | string) | void {
+    return this.path[this.path.length - 1]
+  }
+
+  get target(): T {
+    if (this._target) {
+      return this._target
+    }
+    let p = this.prev
+    while (p) {
+      if (p._target) {
+        return p._target
+      }
+      p = p.prev
+    }
+  }
+
+  stop(onllyStopFieldSchemaParser?: boolean) {
+    const target = this
+    if (onllyStopFieldSchemaParser) {
+      target.stopped = Stopped.onlyStopFieldParser
+    } else {
+      target.stopped = Stopped.stopAll
+    }
+  }
+
+  create(opts?: ArgsOpts<T>): ArgsClass<T> {
+    const newArgs = new ArgsClass(opts, this)
+    if (this._collectOverride) {
+      newArgs._collectOverride = this._collectOverride
+    }
+    if (!('value' in opts)) {
+      newArgs.value = this.value
+    }
+    return newArgs
+  }
+
+  async parse(opts?: ArgsOpts<T>): Promise<ArgsClass<T> | void> {
+    if (!opts) {
+      return parse(this)
+    } else {
+      const newArgs = new ArgsClass(opts, this)
+      if (this._collectOverride) {
+        newArgs._collectOverride = this._collectOverride
+      }
+      return newArgs.parse()
+    }
+  }
+
+  collect(value?: any) {
+    if (this.skipCollection) {
+      return
+    }
+    const collectArgs =
+      value !== undefined ? new ArgsClass({ value }, this) : this
+
+    if (this._collectOverride) {
+      this.collectedCommands.push(this._collectOverride(collectArgs))
+    } else {
+      this.collectedCommands.push(this.root._opts.collect(collectArgs))
+    }
+  }
+
+  error(code: ParseError): void {
+    this.root._opts.error(code, this)
+  }
+}

package/src/walker/index.ts

@@ -0,0 +1,35 @@
+import { BasedSchema } from '../types'
+import { ArgsClass } from './args'
+import { Opts } from './types'
+
+export const walk = async <T>(
+  schema: BasedSchema,
+  opts: Opts<T>,
+  value: any
+): Promise<T> => {
+  if (!('collect' in opts)) {
+    opts.collect = () => {}
+  }
+
+  if (!('error' in opts)) {
+    opts.error = () => {}
+  }
+
+  const argsOpts = await opts.init(value, schema, opts.error)
+
+  if (!argsOpts.value) {
+    argsOpts.value = value
+  }
+
+  const args = new ArgsClass(argsOpts)
+  args.root = args
+  args._opts = opts
+  args._schema = schema
+  await args.parse()
+
+  return args.target
+}
+
+export { ArgsClass }
+
+export * from './types'