@based/schema 0.0.9 → 0.0.11

package/src/set/string.ts

@@ -1,6 +1,11 @@
 import { Parser } from './types'
 import { error, ParseError } from './error'
-import { BasedSchemaFieldString, BasedSchemaFieldText } from '../types'
+import {
+  BasedSchemaFieldString,
+  BasedSchemaFieldText,
+  BasedSchemaLanguage,
+  BasedSetHandlers,
+} from '../types'
 import validators from 'validator'
 import { parseValueAndDefault } from './parseDefaultAndValue'
 
@@ -72,28 +77,30 @@ const formatPatterns: Record<
 }
 
 const validate = (
+  handlers: BasedSetHandlers,
   path: (string | number)[],
   value: string,
   fieldSchema: BasedSchemaFieldText | BasedSchemaFieldString
 ) => {
   if (typeof value !== 'string') {
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
   }
   if (fieldSchema.minLength && value.length < fieldSchema.minLength) {
-    error(path, ParseError.subceedsMinimum)
+    error(handlers, ParseError.subceedsMinimum, path)
   }
   if (fieldSchema.maxLength && value.length > fieldSchema.maxLength) {
-    error(path, ParseError.exceedsMaximum)
+    error(handlers, ParseError.exceedsMaximum, path)
   }
   if (fieldSchema.pattern) {
     const re = new RegExp(fieldSchema.pattern)
     if (!re.test(value)) {
-      error(path, ParseError.incorrectFormat)
+      error(handlers, ParseError.incorrectFormat, path)
     }
   }
   if (fieldSchema.format && !formatPatterns[fieldSchema.format](value)) {
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
   }
+  // return true / false and add collectError
 }
 
 export const string: Parser<'string'> = async (
@@ -118,7 +125,7 @@ export const string: Parser<'string'> = async (
   ) {
     return
   }
-  validate(path, value, fieldSchema)
+  validate(handlers, path, value, fieldSchema)
   if (!noCollect) {
     handlers.collect({ path, value, typeSchema, fieldSchema, target })
   }
@@ -135,7 +142,7 @@ export const text: Parser<'text'> = async (
 ) => {
   const valueType = typeof value
   if (target.$language && valueType === 'string') {
-    validate(path, value, fieldSchema)
+    validate(handlers, path, value, fieldSchema)
     if (!noCollect) {
       handlers.collect({
         path,
@@ -149,7 +156,7 @@ export const text: Parser<'text'> = async (
   }
 
   if (valueType !== 'object') {
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
   }
 
   if (
@@ -161,51 +168,87 @@ export const text: Parser<'text'> = async (
       typeSchema,
       target,
       handlers,
-      noCollect
+      true
     ))
   ) {
+    if (!noCollect) {
+      handlers.collect({
+        path,
+        value: {
+          [target.$language]: value,
+        },
+        typeSchema,
+        fieldSchema,
+        target,
+      })
+    }
+    return
+  } else if (
+    await parseValueAndDefault(
+      path,
+      value,
+      fieldSchema,
+      typeSchema,
+      target,
+      handlers,
+      true
+    )
+  ) {
+    if (!noCollect) {
+      handlers.collect({
+        path,
+        value,
+        typeSchema,
+        fieldSchema,
+        target,
+      })
+    }
     return
   }
 
   for (const key in value) {
-    const newPath = [...path, key]
+    if (!target.schema.languages.includes(<BasedSchemaLanguage>key)) {
+      error(handlers, ParseError.languageNotSupported, path)
+    }
 
     if (typeof value[key] === 'object') {
-      if (value[key].$value) {
-        text(
-          [...path, key, '$value'],
-          value[key].$value,
+      if (
+        await parseValueAndDefault(
+          path,
+          value[key],
           fieldSchema,
           typeSchema,
           target,
           handlers,
           true
         )
+      ) {
+        continue
       }
-      if (!noCollect) {
-        handlers.collect({
-          path: newPath,
-          value: null,
-          typeSchema,
-          fieldSchema,
-          target,
-        })
-      }
-      continue
     }
 
-    // if
-
-    // validate(newPath, value[key], fieldSchema)
-
-    if (!noCollect) {
-      handlers.collect({
-        path: newPath,
-        value: value[key],
-        typeSchema,
+    if (
+      !(await parseValueAndDefault(
+        path,
+        { [key]: value[key] },
         fieldSchema,
+        typeSchema,
         target,
-      })
+        handlers,
+        true
+      ))
+    ) {
+      validate(handlers, path, value[key], fieldSchema)
     }
   }
+
+  if (!noCollect) {
+    handlers.collect({
+      path,
+      value,
+      typeSchema,
+      fieldSchema,
+      target,
+    })
+  }
 }

package/src/types.ts

@@ -1,5 +1,6 @@
 import type { Language } from './languages'
-import type { PartialDeep } from 'type-fest'
+import type { PartialDeep, SetOptional } from 'type-fest'
+import { ParseError } from './set/error'
 
 // Schema type
 // inspiration from https://json-schema.org/understanding-json-schema/index.html
@@ -54,7 +55,11 @@ export type BasedSchemaContentMediaType =
   | 'image/png'
   | 'image/jpeg'
   | 'video/mp4'
-  | string
+  | 'image/*'
+  | 'video/*'
+  | 'audio/*'
+  | '*/*'
+  | `${string}/${string}`
 
 export type BasedSchemaFieldShared = {
   hooks?:
@@ -83,13 +88,12 @@ export type BasedSchemaFieldShared = {
 }
 
 // -------------- Primitive ---------------
-
 export type BasedSchemaStringShared = {
   minLength?: number
   maxLength?: number
   contentMediaEncoding?: string // base64
-  contentMediaType?: BasedSchemaContentMediaType
-  pattern?: BasedSchemaPattern
+  contentMediaType?: BasedSchemaContentMediaType // 'image/*'
+  pattern?: BasedSchemaPattern // TODO: does not exist
   format?:
     | 'email'
     | 'URL'
@@ -340,6 +344,7 @@ export type BasedSetTarget = {
   $id?: string
   schema: BasedSchema
   $language?: BasedSchemaLanguage
+  required: (number | string)[][]
 }
 
 export type BasedSchemaCollectProps = {
@@ -351,17 +356,19 @@ export type BasedSchemaCollectProps = {
 }
 
 export type BasedSetHandlers = {
+  collectErrors: (props: { message: string; code: ParseError }) => void
+
   collect: (props: BasedSchemaCollectProps) => void
 
-  // has to be fixed / decided upon
-  // ['bla[0].xxx', '']
-  // [bla, [0]', xxx]
-  // (number|string)[]
-  // typeschema, target) => Promise<boolean>
+  checkRequiredFields: (path: (string | number)[]) => Promise<boolean>
 
-  // $filter
   referenceFilterCondition: (
     referenceId: string,
     $filter: any
   ) => Promise<boolean>
 }
+
+export type BasedSetOptionalHandlers = SetOptional<
+  BasedSetHandlers,
+  'collectErrors' | 'collect'
+>

package/src/updateSchema.ts

@@ -0,0 +1,18 @@
+import { BasedSchema, BasedSchemaPartial } from './types'
+
+export const updateSchema = async (
+  newSchema: BasedSchemaPartial,
+  oldSchema: BasedSchema = {
+    $defs: {},
+    types: {},
+    languages: ['en'],
+    root: { fields: {} },
+    prefixToTypeMapping: {},
+  }
+): Promise<BasedSchema> => {
+  // add sha
+
+  // put isRequired on the new schema in REQUIRED arrays
+
+  return oldSchema
+}

package/src/validateSchema.ts

@@ -5,6 +5,8 @@ import {
   BasedSchemaField,
 } from './types'
 
+// gaurd in the schema for refs in arrays
+
 export const validateType = (
   fromSchema: BasedSchemaPartial,
   typeName: string,
@@ -24,7 +26,9 @@ export const validateField = (
   fromSchema: BasedSchemaPartial,
   path: string[],
   field: BasedSchemaFieldPartial
-) => {}
+) => {
+  //
+}
 
 export const validateSchema = (
   schema: BasedSchemaPartial
@@ -44,6 +48,7 @@ export const validateSchema = (
   }
 
   if (schema.root) {
+    validateType(schema, 'root', schema.root)
   }
 
   if (schema.types) {

package/src/walker.ts

@@ -0,0 +1,152 @@
+import { ParseError } from './set/error'
+import { BasedSchema, BasedSetHandlers, BasedSetTarget } from './types'
+import { BasedSchemaType, BasedSchemaFields } from './types'
+
+type Path = (string | number)[]
+
+type ErrorHandler<T> = (args: Args<T>, code: ParseError) => void
+
+type Parse<T> = (
+  args: Args<T>,
+  key?: string | number,
+  value?: any
+) => Promise<Args<T> | void> // If true will not continue
+
+export type Args<
+  T,
+  K extends keyof BasedSchemaFields = keyof BasedSchemaFields
+> = {
+  schema: BasedSchema
+  parentValue?: any
+  skipCollection?: boolean
+  fieldSchema?: BasedSchemaFields[K]
+  typeSchema?: BasedSchemaType
+  path: Path
+  value: any
+  target: T
+  parse: Parse<T>
+  collect: (args: Args<T>) => any
+  backtrack: (collectedCommands: any[]) => any
+  requiresAsyncValidaton: (validationType: any) => Promise<any>
+  error: ErrorHandler<T>
+}
+
+export type FieldParser<T, K extends keyof BasedSchemaFields> = (
+  args: Args<T, K>
+) => Promise<Args<T> | void>
+
+export type KeyParser<T> = (
+  args: Args<T, keyof BasedSchemaFields>
+) => Promise<Args<T> | void>
+
+export type Opts<T> = {
+  schema: BasedSchema
+  init: (
+    value: any,
+    opts: Opts<T>,
+    errors: { code: ParseError; message: string }[]
+  ) => Promise<T>
+  parsers: {
+    fields: Partial<{
+      [Key in keyof BasedSchemaFields]: FieldParser<T, Key>
+    }>
+    keys: { [key: string]: KeyParser<T> } // $list -> true
+    any: KeyParser<T> // y.x
+  }
+  collect: (args: Args<T>) => any
+  backtrack: (collectedCommands: any[]) => any // from back TRACKS OR COLLECT
+  requiresAsyncValidaton: (validationType: any) => Promise<boolean>
+}
+
+export const walk = async <T>(
+  opts: Opts<T>,
+  value: any
+): Promise<{
+  target: T
+  errors: { code: ParseError; message: string }[]
+}> => {
+  const errors: { code: ParseError; message: string }[] = []
+  const target = await opts.init(value, opts, errors)
+
+  const errorsCollector: ErrorHandler<T> = (args, code) => {
+    errors.push({
+      code,
+      message: 'flap flap',
+    })
+  }
+
+  const parse: Parse<T> = async (prevArgs, key, value) => {
+    const collectedCommands: any[] = []
+    const fromBackTrack: any[] = []
+    const args: Args<T> = {
+      schema: opts.schema,
+      path: key ? [...prevArgs.path, key] : prevArgs.path,
+      parentValue: value ? prevArgs.value : undefined,
+      value: value ?? prevArgs.value,
+      target,
+      parse: prevArgs.parse,
+      collect: (args) => {
+        collectedCommands.push(opts.collect(args))
+      },
+      backtrack: (args) => {
+        fromBackTrack.push(opts.backtrack(args))
+      },
+      error: errorsCollector,
+      requiresAsyncValidaton: opts.requiresAsyncValidaton,
+    }
+    if (typeof args.value === 'object' && args.value !== null) {
+      const q: Promise<Args<T> | void>[] = []
+      if (Array.isArray(args.value)) {
+        for (let i = 0; i < args.value.length; i++) {
+          //
+          const parser = opts.parsers.keys[i] || opts.parsers.any
+          q.push(
+            parser({ ...args, value: args.value[i], path: [...args.path, i] })
+          )
+        }
+      } else {
+        for (const key in args.value) {
+          const parser = opts.parsers.keys[key] || opts.parsers.any
+          q.push(
+            (async () => {
+              const newArgs = await parser({
+                ...args,
+                value: args.value[key],
+                path: [...args.path, key],
+              })
+
+              if (newArgs) {
+                return parse(newArgs)
+              }
+            })()
+          )
+        }
+      }
+      await Promise.all(q)
+      if (fromBackTrack.length) {
+        opts.backtrack(fromBackTrack)
+      } else if (collectedCommands.length) {
+        opts.backtrack(collectedCommands)
+      }
+    }
+  }
+
+  const args: Args<T> = {
+    schema: opts.schema,
+    path: [],
+    value,
+    target,
+    parse,
+    collect: opts.collect,
+    backtrack: opts.backtrack,
+    error: errorsCollector,
+    requiresAsyncValidaton: opts.requiresAsyncValidaton,
+  }
+
+  parse(args)
+
+  return {
+    target,
+    errors,
+  }
+}