@based/schema 1.3.2 → 2.1.0

package/src/set/fields/references.ts

@@ -1,140 +0,0 @@
-import { ParseError } from '../../error'
-import { AllowedTypes, BasedSetTarget } from '../../types'
-import { ArgsClass, FieldParser } from '../../walker'
-import { isValidId } from '../isValidId'
-
-async function parseOperator<T>(
-  args: ArgsClass<T, 'references'>,
-  key: string
-): Promise<any[]> {
-  if (Array.isArray(args.value[key])) {
-    const n = args.create({
-      key,
-      skipCollection: true,
-      value: args.value[key],
-    })
-    await n.parse()
-
-    if (n.value?.$value) {
-      return n.value.$value
-    }
-    return []
-  }
-  const n = <ArgsClass<BasedSetTarget, 'reference'>>args.create({
-    value: args.value[key],
-    key,
-    skipCollection: true,
-  })
-  await reference(n)
-  return [n.value]
-}
-
-const typeIsAllowed = (
-  args: ArgsClass<BasedSetTarget, 'reference'>,
-  type: string
-): boolean => {
-  if ('allowedTypes' in args.fieldSchema) {
-    let typeMatches = false
-    for (const t of args.fieldSchema.allowedTypes) {
-      if (typeof t === 'string') {
-        if (t === type) {
-          return true
-        }
-      } else {
-        if (t.type && t.type === type) {
-          typeMatches = true
-          if (t.$filter) {
-            // stage on requires validation in target
-            // TODO: ASYNC REQUIRED HOOK
-            // if(!(await args.target.referenceFilterCondition(value, t.$filter))){
-            //     error(args, ParseError.referenceIsIncorrectType)
-            //     return
-            // }
-          }
-        } else if (!t.type && t.$filter) {
-          // if(!(await args.target.referenceFilterCondition))
-          // error(args, ParseError.referenceIsIncorrectType, )
-          // return
-        }
-      }
-    }
-    if (typeMatches === false) {
-      return false
-    }
-  }
-  return true
-}
-
-export const reference: FieldParser<'reference'> = async (args) => {
-  // TODO: setting an object here , handling $alias (both async hooks)
-  // Block if path contains $remove (maybe not for $alias)
-  if (typeof args.value === 'object') {
-    if (args.root._opts.asyncOperationHandler) {
-      if (args.value.type && !typeIsAllowed(args, args.value.type)) {
-        args.error(ParseError.referenceIsIncorrectType)
-        return
-      }
-      if (!args.target.errors.length) {
-        args.value = await args.root._opts.asyncOperationHandler(
-          args,
-          'modifyObject'
-        )
-      }
-    } else {
-      args.error(ParseError.nestedModifyObjectNotAllowed)
-      return
-    }
-  }
-
-  if (!isValidId(args.schema, args.value)) {
-    args.error(ParseError.incorrectFormat)
-    return
-  }
-
-  const prefix = args.value.slice(0, 2)
-  const targetType = args.schema.prefixToTypeMapping[prefix]
-
-  if (typeIsAllowed(args, targetType)) {
-    args.collect()
-  } else {
-    args.error(ParseError.referenceIsIncorrectType)
-  }
-}
-
-export const references: FieldParser<'references'> = async (args) => {
-  const { value } = args
-
-  if (typeof value !== 'object' || value === null) {
-    args.error(ParseError.incorrectFormat)
-    return
-  }
-
-  args.stop()
-
-  if (Array.isArray(value)) {
-    const parseValues = await Promise.all(
-      value.map(async (id, key) => {
-        const n = <ArgsClass<BasedSetTarget, 'reference'>>args.create({
-          value: id,
-          key,
-          skipCollection: true,
-        })
-        await reference(n)
-        return n.value
-      })
-    )
-    args.value = { $value: parseValues }
-  } else {
-    for (const key in args.value) {
-      if (key === '$add') {
-        args.value.$add = await parseOperator(args, key)
-      } else if (key === '$remove') {
-        args.value.$remove = await parseOperator(args, key)
-      } else {
-        args.create({ key }).error(ParseError.fieldDoesNotExist)
-      }
-    }
-  }
-
-  args.collect()
-}

package/src/set/fields/set.ts

@@ -1,63 +0,0 @@
-import { ParseError } from '../../error'
-import { ArgsClass, FieldParser } from '../../walker'
-
-async function parseOperator<T>(
-  args: ArgsClass<T, 'set'>,
-  key: string
-): Promise<any[]> {
-  if (Array.isArray(args.value[key])) {
-    const n = args.create({
-      key,
-      skipCollection: true,
-      value: args.value[key],
-    })
-    await n.parse()
-    if (n.value?.$value) {
-      return n.value.$value
-    }
-    return []
-  }
-  const n = args.create({
-    key,
-    skipCollection: true,
-    value: args.value[key],
-    fieldSchema: args.fieldSchema.items,
-  })
-  await n.parse()
-  return [n.value]
-}
-
-export const set: FieldParser<'set'> = async (args) => {
-  if (typeof args.value !== 'object' || args.value === null) {
-    args.error(ParseError.incorrectFormat)
-    return
-  }
-  args.stop()
-  const isArray = Array.isArray(args.value)
-  if (isArray) {
-    const newArgs: ArgsClass<typeof args.target>[] = []
-    for (let i = 0; i < args.value.length; i++) {
-      newArgs.push(
-        args.create({
-          key: i,
-          value: args.value[i],
-          fieldSchema: args.fieldSchema.items,
-          skipCollection: true,
-        })
-      )
-    }
-    await Promise.all(newArgs.map((args) => args.parse()))
-    args.value = { $value: newArgs.map((args) => args.value) }
-  } else {
-    for (const key in args.value) {
-      if (key === '$add') {
-        args.value.$add = await parseOperator(args, key)
-      } else if (key === '$remove') {
-        args.value.$remove = await parseOperator(args, key)
-      } else {
-        args.create({ key }).error(ParseError.fieldDoesNotExist)
-      }
-    }
-  }
-  args.collect()
-}

package/src/set/fields/string.ts

@@ -1,287 +0,0 @@
-import {
-  BasedSchemaFieldString,
-  BasedSchemaLanguage,
-  BasedSetTarget,
-} from '../../types'
-import { ParseError } from '../../error'
-import { FieldParser, ArgsClass } from '../../walker'
-import validators from 'validator'
-import { deepMerge, setByPath } from '@saulx/utils'
-
-type StringTypes = 'string' | 'text'
-
-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 validateString = (
-  args: ArgsClass<BasedSetTarget, StringTypes>,
-  value: string
-): boolean => {
-  if (typeof value !== 'string') {
-    args.error(ParseError.incorrectFormat)
-    return false
-  }
-  if (args.fieldSchema.minLength && value.length < args.fieldSchema.minLength) {
-    args.error(ParseError.subceedsMinimum)
-    return false
-  }
-  if (args.fieldSchema.maxLength && value.length > args.fieldSchema.maxLength) {
-    args.error(ParseError.exceedsMaximum)
-    return false
-  }
-  if (args.fieldSchema.pattern) {
-    const re = new RegExp(args.fieldSchema.pattern)
-    if (!re.test(value)) {
-      args.error(ParseError.incorrectFormat)
-      return false
-    }
-  }
-  if (
-    args.fieldSchema.format &&
-    !formatPatterns[args.fieldSchema.format](value)
-  ) {
-    args.error(ParseError.incorrectFormat)
-    return false
-  }
-  return true
-}
-
-export const string: FieldParser<'string'> = async (args) => {
-  if (!validateString(args, args.value)) {
-    return
-  }
-  args.collect()
-}
-
-// --- bla
-// if typeof === string
-export const text: FieldParser<'text'> = async (args) => {
-  const value = args.value
-
-  args.stop()
-
-  if (value === null) {
-    args.error(ParseError.incorrectFormat)
-    return
-  }
-
-  if (typeof value === 'object') {
-    for (const key in value) {
-      if (key === '$merge') {
-        if (typeof value.$merge !== 'boolean') {
-          args.error(ParseError.incorrectFormat)
-          return
-        }
-      } else if (key === '$delete') {
-        if (value[key] !== true) {
-          args.error(ParseError.incorrectFormat)
-          return
-        }
-        args.collect({ $delete: true })
-        return
-      } else if (key === '$value') {
-        const valueArgs = args.create({
-          path: args.path,
-          value: args.value[key],
-        })
-        valueArgs._stopObject = true
-        await valueArgs.parse()
-      } else if (key === '$default') {
-        if (value[key] === null) {
-          args.error(ParseError.incorrectFormat)
-          return
-        }
-        if (typeof value[key] === 'object') {
-          for (const k in value[key]) {
-            if (!validateString(args, args.value[key][k])) {
-              args.error(ParseError.incorrectFormat)
-              return
-            }
-            args
-              .create({
-                key: k,
-                fieldSchema: { type: 'string' },
-                value: { $default: args.value[key][k] },
-              })
-              .collect()
-          }
-        } else if (typeof value[key] !== 'string') {
-          args.error(ParseError.incorrectFormat)
-          return
-        } else if (!args.target.$language) {
-          args.error(ParseError.noLanguageFound)
-          return
-        } else if (!validateString(args, value[key])) {
-          args.error(ParseError.incorrectFormat)
-          return
-        } else {
-          args
-            .create({
-              fieldSchema: { type: 'string' },
-              key: args.target.$language,
-              value: { $default: args.value[key] },
-            })
-            .collect()
-        }
-      } else if (args.schema.languages.includes(<BasedSchemaLanguage>key)) {
-        if (value[key] && typeof value[key] === 'object') {
-          for (const k in value[key]) {
-            if (k === '$delete') {
-              if (value[key].$delete !== true) {
-                args.error(ParseError.incorrectFormat)
-                return
-              }
-              args
-                .create({
-                  key,
-                  fieldSchema: { type: 'string' },
-                  value: args.value[key],
-                })
-                .collect()
-            } else if (k === '$value') {
-              if (!validateString(args, value[key].$value)) {
-                args.create({ key }).error(ParseError.incorrectFormat)
-              } else {
-                args
-                  .create({
-                    key,
-                    fieldSchema: { type: 'string' },
-                    value: args.value[key].$value,
-                  })
-                  .collect()
-              }
-            } else if (k === '$default') {
-              if (!validateString(args, value[key].$default)) {
-                args.create({ key }).error(ParseError.incorrectFormat)
-              } else {
-                args
-                  .create({
-                    key,
-                    fieldSchema: { type: 'string' },
-                    value: { $default: args.value[key].$default },
-                  })
-                  .collect()
-              }
-            } else {
-              args
-                .create({ path: [...args.path, key, k] })
-                .error(ParseError.fieldDoesNotExist)
-              return
-            }
-          }
-        } else {
-          if (!validateString(args, args.value[key])) {
-            args.error(ParseError.incorrectFormat)
-            return
-          }
-          args
-            .create({
-              key,
-              fieldSchema: { type: 'string' },
-              value: args.value[key],
-            })
-            .collect()
-        }
-      } else {
-        args.create({ key }).error(ParseError.languageNotSupported)
-      }
-    }
-    if (!args._stopObject) {
-      args.collect()
-    }
-    return
-  }
-
-  if (typeof value !== 'string') {
-    args.error(ParseError.incorrectFormat)
-    return
-  }
-
-  if (!args.target.$language) {
-    args.error(ParseError.noLanguageFound)
-    return
-  }
-
-  if (!validateString(args, args.value)) {
-    args.error(ParseError.incorrectFormat)
-    return
-  }
-
-  args
-    .create({
-      value,
-      key: args.target.$language,
-      fieldSchema: { type: 'string' },
-    })
-    .collect()
-
-  if (!args._stopObject) {
-    args.collect({
-      [args.target.$language]: value,
-    })
-  }
-}

package/src/set/index.ts

@@ -1,182 +0,0 @@
-import { ParseError } from '../error'
-import { BasedSchema, BasedSchemaCollectProps, BasedSetTarget } from '../types'
-import { walk, Opts, AsyncOperation } from '../walker'
-import { fields } from './fields'
-import { isValidId } from './isValidId'
-
-const opts: Opts<BasedSetTarget> = {
-  parsers: {
-    keys: {
-      $delete: async (args) => {
-        if (args.prev === args.root) {
-          args.error(ParseError.cannotDeleteNodeFromModify)
-          return
-        }
-        if (args.value === true) {
-          args.stop()
-          args.prev.collect()
-          args.prev.stop()
-          return
-        }
-      },
-      $alias: async (args) => {
-        if (Array.isArray(args.value)) {
-          for (const field of args.value) {
-            if (typeof field !== 'string') {
-              args.error(ParseError.incorrectFormat)
-              return
-            }
-          }
-          return
-        }
-        if (typeof args.value !== 'string') {
-          args.error(ParseError.incorrectFormat)
-        }
-      },
-      $merge: async (args) => {
-        if (typeof args.value !== 'boolean') {
-          args.error(ParseError.incorrectFormat)
-          return
-        }
-
-        if (args.prev !== args.root) {
-          args.prev.collect({ $delete: true })
-        }
-
-        return
-      },
-      $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' || type === 'set' || type == 'references') {
-          return
-        }
-        args.prev.stop()
-        args.stop()
-        if (args.prev.value.$default) {
-          args.error(ParseError.valueAndDefault)
-          return
-        }
-        return {
-          path: args.path.slice(0, -1),
-          value: args.value,
-        }
-      },
-      $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()
-        args.stop()
-
-        if (type === 'references' || type === 'set' || type === 'array') {
-          const newArgs = args.create({
-            path: args.path.slice(0, -1),
-            skipCollection: true,
-          })
-          await newArgs.parse()
-          newArgs.skipCollection = false
-          newArgs.value = { $default: newArgs.value }
-          newArgs.collect()
-        } else {
-          const collect = args._collectOverride ?? args.root._opts.collect
-          const newArgs = args.create({
-            path: args.path.slice(0, -1),
-            collect: (a) => {
-              if (a.path.length === args.path.length - 1) {
-                collect(a.create({ value: { $default: a.value } }))
-              } else {
-                // console.info('hello', a.path) can handle this later
-              }
-            },
-          })
-          await newArgs.parse()
-        }
-        for (const key in args.prev.value) {
-          if (key !== '$default') {
-            args.prev.create({ key }).error(ParseError.fieldDoesNotExist)
-          }
-        }
-      },
-    },
-    fields,
-    catch: async (args) => {
-      args.error(ParseError.fieldDoesNotExist)
-    },
-  },
-  init: async (value, schema, error) => {
-    let type: string
-    const target: BasedSetTarget = {
-      type,
-      schema,
-      required: [],
-      collected: [],
-      errors: [],
-    }
-    if (value.$id) {
-      if (value.$id === 'root') {
-        type = 'root'
-      } else {
-        type = schema.prefixToTypeMapping[value.$id.slice(0, 2)]
-      }
-      if (!type) {
-        error(ParseError.incorrectFieldType, { target })
-        return { target }
-      }
-    } else if (value.$alias) {
-      target.$alias = value.$alias
-    }
-    if (value.type) {
-      if (type && value.type !== type) {
-        error(ParseError.incorrectNodeType, { target })
-        return { target }
-      }
-      type = value.type
-    }
-    const typeSchema = type === 'root' ? schema.root : schema.types[type]
-    if (!typeSchema) {
-      error(ParseError.incorrectNodeType, { target })
-      return { target }
-    }
-    target.type = type
-    target.$language = value.$language
-    target.$id = value.$id
-    if ('$merge' in value) {
-      if (typeof value.$merge !== 'boolean') {
-        error(ParseError.incorrectFormat, { target })
-      }
-      target.$merge = value.$merge
-    }
-    return { target, typeSchema }
-  },
-  error: (code, args) => {
-    args.target.errors.push({
-      code,
-      path: args.path ?? [],
-    })
-  },
-  collect: (args) => {
-    args.root.target.collected.push(<BasedSchemaCollectProps>args)
-  },
-}
-
-export const setWalker = (
-  schema: BasedSchema,
-  value: any,
-  asyncOperationHandler?: AsyncOperation<BasedSetTarget>
-): Promise<BasedSetTarget> => {
-  return walk<BasedSetTarget>(schema, opts, value, asyncOperationHandler)
-}

package/src/set/isValidId.ts

@@ -1,23 +0,0 @@
-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 > 16) {
-    return false
-  }
-
-  const prefix = id.slice(0, 2)
-
-  if (!schema.prefixToTypeMapping[prefix]) {
-    return false
-  }
-
-  return true
-}