@based/schema 0.0.16 → 1.0.1

package/src/set/rest.ts

@@ -1,135 +0,0 @@
-import { Parser } from './types'
-import { deepEqual } from '@saulx/utils'
-import { hashObjectIgnoreKeyOrder, hash } from '@saulx/hash'
-import { error, ParseError } from './error'
-import { parseValueAndDefault } from './parseDefaultAndValue'
-
-export const cardinality: Parser<'cardinality'> = async (
-  path,
-  value,
-  fieldSchema,
-  typeSchema,
-  target,
-  handlers,
-  noCollect
-) => {
-  if (value && typeof value === 'object') {
-    if (value.$default !== undefined) {
-      error(handlers, ParseError.defaultNotSupported, path)
-    }
-    if (value.$value !== undefined) {
-      value = hashObjectIgnoreKeyOrder(value.$value).toString(16)
-    } else {
-      value = hashObjectIgnoreKeyOrder(value).toString(16)
-    }
-  } else {
-    value = hash(value).toString(16)
-  }
-  if (!noCollect) {
-    handlers.collect({ path, value, typeSchema, fieldSchema, target })
-  }
-}
-
-export const boolean: Parser<'boolean'> = async (
-  path,
-  value,
-  fieldSchema,
-  typeSchema,
-  target,
-  handlers,
-  noCollect
-) => {
-  if (
-    await parseValueAndDefault(
-      path,
-      value,
-      fieldSchema,
-      typeSchema,
-      target,
-      handlers,
-      noCollect
-    )
-  ) {
-    return
-  }
-
-  if (typeof value !== 'boolean') {
-    error(handlers, ParseError.incorrectFormat, path)
-  }
-
-  if (!noCollect) {
-    handlers.collect({ path, value, typeSchema, fieldSchema, target })
-  }
-}
-
-export const enumParser: Parser<'enum'> = async (
-  path,
-  value,
-  fieldSchema,
-  typeSchema,
-  target,
-  handlers,
-  noCollect
-) => {
-  const enumValues = fieldSchema.enum
-  if (
-    !(await parseValueAndDefault(
-      path,
-      value,
-      fieldSchema,
-      typeSchema,
-      target,
-      handlers,
-      noCollect
-    ))
-  ) {
-    for (let i = 0; i < enumValues.length; i++) {
-      if (deepEqual(enumValues[i], value)) {
-        if (!noCollect) {
-          handlers.collect({ path, value: i, typeSchema, fieldSchema, target })
-        }
-        return
-      }
-    }
-    error(handlers, ParseError.incorrectFormat, path)
-  }
-}
-
-export const json: Parser<'json'> = async (
-  path,
-  value,
-  fieldSchema,
-  typeSchema,
-  target,
-  handlers,
-  noCollect
-) => {
-  if (
-    await parseValueAndDefault(
-      path,
-      value,
-      fieldSchema,
-      typeSchema,
-      target,
-      handlers,
-      noCollect
-    )
-  ) {
-    return
-  }
-
-  try {
-    const parsedValue = JSON.stringify(value)
-    if (!noCollect) {
-      handlers.collect({
-        path,
-        value: parsedValue,
-        typeSchema,
-        fieldSchema,
-        target,
-      })
-    }
-  } catch (err) {
-    error(handlers, ParseError.incorrectFormat, path)
-  }
-}

package/src/set/string.ts

@@ -1,254 +0,0 @@
-import { Parser } from './types'
-import { error, ParseError } from './error'
-import {
-  BasedSchemaFieldString,
-  BasedSchemaFieldText,
-  BasedSchemaLanguage,
-  BasedSetHandlers,
-} from '../types'
-import validators from 'validator'
-import { parseValueAndDefault } from './parseDefaultAndValue'
-
-const formatPatterns: Record<
-  BasedSchemaFieldString['format'],
-  (str: string) => boolean
-> = {
-  email: validators.isEmail,
-  URL: validators.isURL,
-  MACAddress: validators.isMACAddress,
-  IP: validators.isIP,
-  IPRange: validators.isIPRange,
-  FQDN: validators.isFQDN,
-  IBAN: validators.isIBAN,
-  BIC: validators.isBIC,
-  alpha: validators.isAlpha,
-  alphaLocales: validators.isAlphaLocales,
-  alphanumeric: validators.isAlphanumeric,
-  alphanumericLocales: validators.isAlphanumericLocales,
-  passportNumber: validators.isPassportNumber,
-  port: validators.isPort,
-  lowercase: validators.isLowercase,
-  uppercase: validators.isUppercase,
-  ascii: validators.isAscii,
-  semVer: validators.isSemVer,
-  surrogatePair: validators.isSurrogatePair,
-  IMEI: validators.isIMEI,
-  hexadecimal: validators.isHexadecimal,
-  octal: validators.isOctal,
-  hexColor: validators.isHexColor,
-  rgbColor: validators.isRgbColor,
-  HSL: validators.isHSL,
-  ISRC: validators.isISRC,
-  MD5: validators.isMD5,
-  JWT: validators.isJWT,
-  UUID: validators.isUUID,
-  luhnNumber: validators.isLuhnNumber,
-  creditCard: validators.isCreditCard,
-  identityCard: validators.isIdentityCard,
-  EAN: validators.isEAN,
-  ISIN: validators.isISIN,
-  ISBN: validators.isISBN,
-  ISSN: validators.isISSN,
-  mobilePhone: validators.isMobilePhone,
-  mobilePhoneLocales: validators.isMobilePhoneLocales,
-  postalCode: validators.isPostalCode,
-  postalCodeLocales: validators.isPostalCodeLocales,
-  ethereumAddress: validators.isEthereumAddress,
-  currency: validators.isCurrency,
-  btcAddress: validators.isBtcAddress,
-  ISO6391: validators.isISO6391,
-  ISO8601: validators.isISO8601,
-  RFC3339: validators.isRFC3339,
-  ISO31661Alpha2: validators.isISO31661Alpha2,
-  ISO31661Alpha3: validators.isISO31661Alpha3,
-  ISO4217: validators.isISO4217,
-  base32: validators.isBase32,
-  base58: validators.isBase58,
-  base64: validators.isBase64,
-  dataURI: validators.isDataURI,
-  magnetURI: validators.isMagnetURI,
-  mimeType: validators.isMimeType,
-  latLong: validators.isLatLong,
-  slug: validators.isSlug,
-  strongPassword: validators.isStrongPassword,
-  taxID: validators.isTaxID,
-  licensePlate: validators.isLicensePlate,
-  VAT: validators.isVAT,
-}
-
-const validate = (
-  handlers: BasedSetHandlers,
-  path: (string | number)[],
-  value: string,
-  fieldSchema: BasedSchemaFieldText | BasedSchemaFieldString
-) => {
-  if (typeof value !== 'string') {
-    error(handlers, ParseError.incorrectFormat, path)
-  }
-  if (fieldSchema.minLength && value.length < fieldSchema.minLength) {
-    error(handlers, ParseError.subceedsMinimum, path)
-  }
-  if (fieldSchema.maxLength && value.length > fieldSchema.maxLength) {
-    error(handlers, ParseError.exceedsMaximum, path)
-  }
-  if (fieldSchema.pattern) {
-    const re = new RegExp(fieldSchema.pattern)
-    if (!re.test(value)) {
-      error(handlers, ParseError.incorrectFormat, path)
-    }
-  }
-  if (fieldSchema.format && !formatPatterns[fieldSchema.format](value)) {
-    error(handlers, ParseError.incorrectFormat, path)
-  }
-  // return true / false and add collectError
-}
-
-export const string: Parser<'string'> = async (
-  path,
-  value,
-  fieldSchema,
-  typeSchema,
-  target,
-  handlers,
-  noCollect
-) => {
-  if (
-    await parseValueAndDefault(
-      path,
-      value,
-      fieldSchema,
-      typeSchema,
-      target,
-      handlers,
-      noCollect
-    )
-  ) {
-    return
-  }
-  validate(handlers, path, value, fieldSchema)
-  if (!noCollect) {
-    handlers.collect({ path, value, typeSchema, fieldSchema, target })
-  }
-}
-
-export const text: Parser<'text'> = async (
-  path,
-  value,
-  fieldSchema,
-  typeSchema,
-  target,
-  handlers,
-  noCollect
-) => {
-  const valueType = typeof value
-  if (target.$language && valueType === 'string') {
-    validate(handlers, path, value, fieldSchema)
-    if (!noCollect) {
-      handlers.collect({
-        path,
-        value: { [target.$language]: value },
-        typeSchema,
-        fieldSchema,
-        target,
-      })
-    }
-    return
-  }
-
-  if (valueType !== 'object') {
-    error(handlers, ParseError.incorrectFormat, path)
-  }
-
-  if (
-    target.$language &&
-    (await parseValueAndDefault(
-      path,
-      value,
-      fieldSchema,
-      typeSchema,
-      target,
-      handlers,
-      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) {
-    if (!target.schema.languages.includes(<BasedSchemaLanguage>key)) {
-      error(handlers, ParseError.languageNotSupported, path)
-    }
-
-    if (typeof value[key] === 'object') {
-      if (
-        await parseValueAndDefault(
-          path,
-          value[key],
-          fieldSchema,
-          typeSchema,
-          target,
-          handlers,
-          true
-        )
-      ) {
-        continue
-      }
-    }
-
-    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/set2/index.ts

@@ -1,71 +0,0 @@
-// import { ParseError } from '../set/error'
-// import { BasedSchema, BasedSetTarget } from '../types'
-// import { walk } from '../walker'
-
-// export const setWalker2 = (schema: BasedSchema, value: any) => {
-//   return walk<BasedSetTarget>(
-//     {
-//       schema,
-//       parsers: {
-//         keys: {},
-//         fields: {
-//           object: async (args) => {
-//             if (typeof value !== 'object') {
-//               args.error(args, ParseError.incorrectFormat)
-//               return
-//             }
-//             const isArray = Array.isArray(value)
-//             if (isArray) {
-//               args.error(args, ParseError.incorrectFormat)
-//               return
-//             }
-//             const q: Promise<any>[] = []
-//             for (const key in value) {
-//               q.push(args.parse(args, key, value[key]))
-//             }
-//             await Promise.all(q)
-//           },
-//           boolean: async (args) => {
-//             if (typeof value !== 'boolean') {
-//               args.error(args, ParseError.incorrectFormat)
-//               return
-//             }
-//             args.collect(args)
-//           },
-//         },
-//         any: async (args) => {
-//           args.error(args, ParseError.fieldDoesNotExist)
-//         },
-//       },
-//       init: async (value, args) => {
-//         let type: string
-//         if (value.$id) {
-//           type = schema.prefixToTypeMapping[value.$id.slice(0, 2)]
-//           if (!type) {
-//             args.error(args, ParseError.incorrectFieldType)
-//             return
-//           }
-//         }
-//         if (value.type) {
-//           if (type && value.type !== type) {
-//             args.error(args, ParseError.incorrectNodeType)
-//             return
-//           }
-//           type = value.type
-//         }
-//         const schemaType = schema.types[type]
-//         if (!schemaType) {
-//           args.error(args, ParseError.incorrectNodeType)
-//           return
-//         }
-//         const target: BasedSetTarget = {
-//           type,
-//           schema,
-//           required: [],
-//         }
-//         return { ...args, target }
-//       },
-//     },
-//     value
-//   )
-// }

package/src/walker.ts

@@ -1,201 +0,0 @@
-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
-
-type BackTrack<T> = (
-  args: Args<T>,
-  fromBackTrack: any[],
-  collectedCommands: any[]
-) => any
-
-export type Args<
-  T,
-  K extends keyof BasedSchemaFields = keyof BasedSchemaFields
-> = {
-  schema: BasedSchema
-  parentValue?: any
-  skipCollection?: boolean
-  fieldSchema?: BasedSchemaFields[K]
-  typeSchema?: BasedSchemaType
-  path: Path
-  key?: number | string
-  value: any
-  target: T
-  fromBackTrack: any[]
-  parse: Parse<T>
-  collect: (args: Args<T>) => any
-  backtrack: BackTrack<T>
-  requiresAsyncValidation: (validationType: any) => Promise<any>
-  error: ErrorHandler<T>
-}
-
-export type FieldParser<K extends keyof BasedSchemaFields, T = any> = (
-  args: Args<T, K>
-) => Promise<Args<T> | void>
-
-export type KeyParser<T = any> = (
-  args: Args<T, keyof BasedSchemaFields>
-) => Promise<Args<T> | void>
-
-export type Opts<T> = {
-  schema: BasedSchema
-  init: (args: Args<T>) => Promise<Args<T>>
-  parsers: {
-    fields: Partial<{
-      [Key in keyof BasedSchemaFields]: FieldParser<Key, T>
-    }>
-    keys: { [key: string]: KeyParser<T> } // $list -> true
-    any: KeyParser<T> // y.x
-  }
-  collect?: (args: Args<T>) => any
-  backtrack?: BackTrack<T>
-  requiresAsyncValidation?: (validationType: any) => Promise<boolean>
-  errorsCollector?: ErrorHandler<T>
-}
-
-export const walk = async <T>(
-  opts: Opts<T>,
-  value: any
-): Promise<{
-  target: T
-  errors: { code: ParseError; message: string }[]
-}> => {
-  const errors: { code: ParseError; message: string }[] = []
-
-  if (!('collect' in opts)) {
-    opts.collect = () => {}
-  }
-
-  if (!('backtrack' in opts)) {
-    opts.backtrack = (args, btC, c) => btC
-  }
-
-  if (!('requiresAsyncValidation' in opts)) {
-    opts.requiresAsyncValidation = async () => true
-  }
-
-  const errorsCollector: ErrorHandler<T> = (args, code) => {
-    const err = {
-      code,
-      message: `Error in ${args.path.join('.')}`,
-    }
-    if (opts.errorsCollector) {
-      opts.errorsCollector(args, code)
-    }
-    errors.push(err)
-  }
-
-  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,
-      key: key ?? prevArgs.path[prevArgs.path.length - 1],
-      parentValue: value ? prevArgs.value : undefined,
-      value: value ?? prevArgs.value,
-      target: prevArgs.target,
-      parse: prevArgs.parse,
-      collect: (args) => {
-        collectedCommands.push(opts.collect(args))
-      },
-      fromBackTrack,
-      backtrack: opts.backtrack,
-      error: errorsCollector,
-      requiresAsyncValidation: prevArgs.requiresAsyncValidation,
-    }
-    if (typeof args.value === 'object' && args.value !== null) {
-      const q: Promise<Args<T> | void>[] = []
-
-      if (args.typeSchema && !args.fieldSchema) {
-        // top level
-      }
-
-      if (args.fieldSchema) {
-        //
-      }
-
-      // first do key parsers
-
-      if (Array.isArray(args.value)) {
-        for (let i = 0; i < args.value.length; i++) {
-          const parser = opts.parsers.keys[i] || opts.parsers.any
-          const j = i
-          q.push(
-            (async () => {
-              const newArgs = await parser({
-                ...args,
-                value: args.value[j],
-                path: [...args.path, j],
-                key: j,
-              })
-              if (newArgs) {
-                return parse(newArgs)
-              }
-            })()
-          )
-        }
-      } 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],
-                key,
-              })
-              if (newArgs) {
-                return parse(newArgs)
-              }
-            })()
-          )
-        }
-      }
-
-      await Promise.all(q)
-
-      if (fromBackTrack.length || collectedCommands.length) {
-        const x = args.backtrack(args, fromBackTrack, collectedCommands)
-        if (x) {
-          prevArgs.fromBackTrack?.push(x)
-        }
-      }
-    }
-  }
-  const args: Args<T> = await opts.init(<Args<T>>{
-    schema: opts.schema,
-    path: [],
-    value,
-    parse,
-    collect: opts.collect,
-    backtrack: opts.backtrack,
-    error: errorsCollector,
-    requiresAsyncValidation: opts.requiresAsyncValidation,
-  })
-
-  if (!args) {
-    return {
-      // TODO: temp
-      // @ts-ignore // for now
-      target: {},
-      errors,
-    }
-  }
-  await parse(args)
-  return {
-    target: args.target,
-    errors,
-  }
-}