@based/schema 0.0.10 → 0.0.12

package/src/set/index.ts

@@ -4,9 +4,12 @@ import {
   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)[],
@@ -34,13 +37,13 @@ export const fieldWalker = async (
   const typeDef = fieldSchema.type ?? ('enum' in fieldSchema ? 'enum' : '')
 
   if (!typeDef) {
-    error(path, ParseError.fieldDoesNotExist)
+    error(handlers, ParseError.fieldDoesNotExist, path)
   }
 
   if ('customValidator' in fieldSchema) {
     const customValidator = fieldSchema.customValidator
     if (!(await customValidator(value, path, target))) {
-      error(path, ParseError.incorrectFormat)
+      error(handlers, ParseError.incorrectFormat, path)
     }
   }
 
@@ -54,20 +57,51 @@ export const fieldWalker = async (
 export const setWalker = async (
   schema: BasedSchema,
   value: { [key: string]: any },
-  handlers: BasedSetHandlers
+  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([value.$id], ParseError.incorrectNodeType)
+      error(handlers, ParseError.incorrectNodeType, [value.$id])
     }
   }
 
   if (value.type) {
     if (type && value.type !== type) {
-      error([value.$id, value.type], ParseError.incorrectNodeType)
+      error(handlers, ParseError.incorrectNodeType, [value.$id, value.type])
     }
     type = value.type
   }
@@ -75,7 +109,7 @@ export const setWalker = async (
   const schemaType = schema.types[type]
 
   if (!schemaType) {
-    error([type], ParseError.incorrectNodeType)
+    error(handlers, ParseError.incorrectNodeType, [type])
   }
 
   const target: BasedSetTarget = {
@@ -84,6 +118,13 @@ export const setWalker = async (
     required: [],
   }
 
+  if (value.$language) {
+    if (!schema.languages.includes(value.$language)) {
+      error(handlers, ParseError.languageNotSupported, ['$language'])
+    }
+    target.$language = value.$language
+  }
+
   if (value.$id) {
     target.$id = value.$id
   } else if (value.$alias) {
@@ -96,7 +137,7 @@ export const setWalker = async (
     if (key[0] !== '$' && key !== 'type') {
       const fieldSchema = schemaType.fields[key]
       if (!fieldSchema) {
-        error([key], ParseError.fieldDoesNotExist)
+        error(handlers, ParseError.fieldDoesNotExist, [key])
       } else {
         q.push(
           fieldWalker(
@@ -131,10 +172,26 @@ export const setWalker = async (
     for (let i = 0; i < requireDefined.length; i++) {
       if (!requireDefined[i]) {
         const r = target.required[i]
-        error(r, ParseError.requiredFieldNotDefined)
+        error(handlers, ParseError.requiredFieldNotDefined, r)
       }
     }
   }
 
+  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)
+    }
+  }
+
   return target
 }

package/src/set/number.ts

@@ -4,21 +4,25 @@ import {
   BasedSchemaFieldInteger,
   BasedSchemaFieldNumber,
   BasedSchemaFieldTimeStamp,
+  BasedSetHandlers,
 } from '../types'
 
 const validate = (
+  handlers: BasedSetHandlers,
   path: (number | string)[],
   value: any,
   fieldSchema:
     | BasedSchemaFieldInteger
     | BasedSchemaFieldNumber
     | BasedSchemaFieldTimeStamp
-): number => {
+): number | false => {
   if (typeof value !== 'number') {
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
+    return false
   }
   if (fieldSchema.type === 'integer' && value - Math.floor(value) !== 0) {
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
+    return false
   }
   if (
     fieldSchema.multipleOf &&
@@ -26,26 +30,36 @@ const validate = (
       Math.floor(value / fieldSchema.multipleOf) !==
       0
   ) {
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
+    return false
   }
   if (fieldSchema.maximum) {
-    if (fieldSchema.exclusiveMaximum && value > value) {
-      error(path, ParseError.exceedsMaximum)
-    } else if (value >= value) {
-      error(path, ParseError.exceedsMaximum)
+    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 && value < value) {
-      error(path, ParseError.subceedsMinimum)
-    } else if (value <= value) {
-      error(path, ParseError.subceedsMinimum)
+    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:
@@ -55,22 +69,23 @@ const shared = (
 ): any => {
   if (typeof value === 'object') {
     if (value.$increment) {
-      validate([...path, '$increment'], value.$increment, fieldSchema)
+      validate(handlers, [...path, '$increment'], value.$increment, fieldSchema)
     }
     if (value.$decrement) {
-      validate([...path, '$decrement'], value.$decrement, fieldSchema)
+      validate(handlers, [...path, '$decrement'], value.$decrement, fieldSchema)
     }
     if (value.$value !== undefined) {
-      validate(path, value.$value, fieldSchema)
+      validate(handlers, path, value.$value, fieldSchema)
     }
     if (value.$default !== undefined) {
       if (value.$value !== undefined) {
-        error(path, ParseError.valueAndDefault)
+        error(handlers, ParseError.valueAndDefault, path)
+        return
       }
-      validate(path, value.$default, fieldSchema)
+      validate(handlers, path, value.$default, fieldSchema)
     }
   } else {
-    validate(path, value, fieldSchema)
+    validate(handlers, path, value, fieldSchema)
   }
   return value
 }
@@ -85,17 +100,19 @@ export const timestamp: Parser<'timestamp'> = async (
   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(path, ParseError.incorrectFormat)
+        error(handlers, ParseError.incorrectFormat, path)
+        return
       }
     }
   }
-  const parsedValue = shared(path, value, fieldSchema)
+  const parsedValue = shared(handlers, path, value, fieldSchema)
   if (!noCollect) {
     handlers.collect({
       path,
@@ -116,7 +133,7 @@ export const number: Parser<'number'> = async (
   handlers,
   noCollect
 ) => {
-  const parsedValue = shared(path, value, fieldSchema)
+  const parsedValue = shared(handlers, path, value, fieldSchema)
   if (!noCollect) {
     handlers.collect({
       path,
@@ -137,7 +154,7 @@ export const integer: Parser<'integer'> = async (
   handlers,
   noCollect
 ) => {
-  const parsedValue = shared(path, value, fieldSchema)
+  const parsedValue = shared(handlers, path, value, fieldSchema)
   if (!noCollect) {
     handlers.collect({
       path,

package/src/set/parseDefaultAndValue.ts

@@ -18,14 +18,23 @@ export const parseValueAndDefault: Parser<keyof BasedSchemaFields> = async (
     const parse = parsers[typeDef]
     if (value.$value !== undefined) {
       // TODO: for errors handle path a bit smarter...
-      parse(path, value.$value, fieldSchema, typeSchema, target, handlers, true)
+      await parse(
+        path,
+        value.$value,
+        fieldSchema,
+        typeSchema,
+        target,
+        handlers,
+        true
+      )
       handled = true
     }
     if (value.$default !== undefined) {
       if (value.$value !== undefined) {
-        error(path, ParseError.valueAndDefault)
+        error(handlers, ParseError.valueAndDefault, path)
       }
-      parse(
+      console.info('->', path, 'go')
+      await parse(
         path,
         value.$default,
         fieldSchema,
@@ -38,6 +47,7 @@ export const parseValueAndDefault: Parser<keyof BasedSchemaFields> = async (
     }
   }
   if (handled && !noCollect) {
+    console.log('collect?')
     handlers.collect({ path, value, typeSchema, fieldSchema, target })
   }
   return handled

package/src/set/references.ts

@@ -16,14 +16,15 @@ export const reference: Parser<'reference'> = async (
   // $value
 
   if (typeof value !== 'string') {
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
   }
 
   if ('allowedTypes' in fieldSchema) {
     const prefix = value.slice(0, 2)
     const targetType = target.schema.prefixToTypeMapping[prefix]
     if (!targetType) {
-      error(path, ParseError.referenceIsIncorrectType)
+      error(handlers, ParseError.referenceIsIncorrectType, path)
+      return
     }
     let typeMatches = false
     for (const t of fieldSchema.allowedTypes) {
@@ -37,18 +38,21 @@ export const reference: Parser<'reference'> = async (
           typeMatches = true
           if (t.$filter) {
             if (!(await handlers.referenceFilterCondition(value, t.$filter))) {
-              error(path, ParseError.referenceIsIncorrectType)
+              error(handlers, ParseError.referenceIsIncorrectType, path)
+              return
             }
           }
         } else if (!t.type && t.$filter) {
           if (!(await handlers.referenceFilterCondition(value, t.$filter))) {
-            error(path, ParseError.referenceIsIncorrectType)
+            error(handlers, ParseError.referenceIsIncorrectType, path)
+            return
           }
         }
       }
     }
     if (typeMatches === false) {
-      error(path, ParseError.referenceIsIncorrectType)
+      error(handlers, ParseError.referenceIsIncorrectType, path)
+      return
     }
   }
   if (!noCollect) {
@@ -100,6 +104,8 @@ export const references: Parser<'references'> = async (
         })
       )
     }
+  } else {
+    error(handlers, ParseError.incorrectFormat, path)
   }
   if (!noCollect) {
     handlers.collect({ path, value, typeSchema, fieldSchema, target })

package/src/set/rest.ts

@@ -15,7 +15,7 @@ export const cardinality: Parser<'cardinality'> = async (
 ) => {
   if (value && typeof value === 'object') {
     if (value.$default !== undefined) {
-      error(path, ParseError.defaultNotSupported)
+      error(handlers, ParseError.defaultNotSupported, path)
     }
     if (value.$value !== undefined) {
       value = hashObjectIgnoreKeyOrder(value.$value).toString(16)
@@ -54,7 +54,7 @@ export const boolean: Parser<'boolean'> = async (
   }
 
   if (typeof value !== 'boolean') {
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
   }
 
   if (!noCollect) {
@@ -91,7 +91,7 @@ export const enumParser: Parser<'enum'> = async (
         return
       }
     }
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
   }
 }
 
@@ -130,6 +130,6 @@ export const json: Parser<'json'> = async (
       })
     }
   } catch (err) {
-    error(path, ParseError.incorrectFormat)
+    error(handlers, ParseError.incorrectFormat, path)
   }
 }

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,9 +168,20 @@ 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(
@@ -189,36 +207,30 @@ export const text: Parser<'text'> = async (
   }
 
   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 (
       !(await parseValueAndDefault(
         path,
-        { $language: key, [key]: value[key] },
+        { [key]: value[key] },
         fieldSchema,
         typeSchema,
         target,
@@ -226,17 +238,17 @@ export const text: Parser<'text'> = async (
         true
       ))
     ) {
-      validate(newPath, value[key], fieldSchema)
+      validate(handlers, path, value[key], fieldSchema)
     }
+  }
 
-    if (!noCollect) {
-      handlers.collect({
-        path: newPath,
-        value: value[key],
-        typeSchema,
-        fieldSchema,
-        target,
-      })
-    }
+  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'
@@ -352,9 +356,9 @@ export type BasedSchemaCollectProps = {
 }
 
 export type BasedSetHandlers = {
-  collect: (props: BasedSchemaCollectProps) => void
+  collectErrors: (props: { message: string; code: ParseError }) => void
 
-  // add collectNeedRequired
+  collect: (props: BasedSchemaCollectProps) => void
 
   checkRequiredFields: (path: (string | number)[]) => Promise<boolean>
 
@@ -363,3 +367,8 @@ export type BasedSetHandlers = {
     $filter: any
   ) => Promise<boolean>
 }
+
+export type BasedSetOptionalHandlers = SetOptional<
+  BasedSetHandlers,
+  'collectErrors' | 'collect'
+>