@based/schema 0.0.15 → 1.0.1

package/src/set/fields/number.ts

@@ -0,0 +1,134 @@
+import { ParseError } from '../../error'
+import { FieldParser, ArgsClass } from '../../walker'
+import { BasedSetTarget } from '../../types'
+
+type NumberTypes = 'number' | 'timestamp' | 'integer'
+
+const validateNumber = (
+  args: ArgsClass<BasedSetTarget, NumberTypes>,
+  value: number,
+  ignoreMinMax?: boolean
+): boolean => {
+  const { fieldSchema } = args
+  if (typeof value !== 'number') {
+    args.error(ParseError.incorrectFormat)
+    return false
+  }
+
+  if (fieldSchema.type === 'integer' && value - Math.floor(value) !== 0) {
+    args.error(ParseError.incorrectFormat)
+    return false
+  }
+
+  if (
+    fieldSchema.multipleOf &&
+    value / fieldSchema.multipleOf -
+      Math.floor(value / fieldSchema.multipleOf) !==
+      0
+  ) {
+    args.error(ParseError.incorrectFormat)
+    return false
+  }
+
+  if (ignoreMinMax) {
+    // TODO: maybe add async validator getting the actual value from the db OR checking the result of the $incr/$decr operation
+    return true
+  }
+
+  if (fieldSchema.maximum) {
+    if (fieldSchema.exclusiveMaximum) {
+      if (value >= fieldSchema.maximum) {
+        args.error(ParseError.exceedsMaximum)
+        return false
+      }
+    } else if (value > fieldSchema.maximum) {
+      args.error(ParseError.exceedsMaximum)
+      return false
+    }
+  }
+
+  if (fieldSchema.minimum) {
+    if (fieldSchema.exclusiveMinimum) {
+      if (value <= fieldSchema.minimum) {
+        args.error(ParseError.subceedsMinimum)
+        return false
+      }
+    } else if (value < fieldSchema.minimum) {
+      args.error(ParseError.subceedsMinimum)
+      return false
+    }
+  }
+
+  return true
+}
+
+const validate = (
+  args: ArgsClass<BasedSetTarget, NumberTypes>,
+  value: any
+): boolean => {
+  if (value === null) {
+    return false
+  }
+
+  if (typeof value !== 'object') {
+    return validateNumber(args, value)
+  }
+  if ('$value' in value) {
+    return
+  }
+
+  args.stop()
+  for (const key in value) {
+    if (key === '$default') {
+      if (!validateNumber(args, value.$default)) {
+        return false
+      }
+    } else if (key === '$increment') {
+      if (!validateNumber(args, value.$increment, true)) {
+        return false
+      }
+    } else if (key === '$decrement') {
+      if (!validateNumber(args, value.$decrement, true)) {
+        return false
+      }
+    } else {
+      args.create({ key }).error(ParseError.fieldDoesNotExist)
+      return false
+    }
+  }
+  return true
+}
+
+export const number: FieldParser<'number'> = async (args) => {
+  if (!validate(args, args.value)) {
+    return
+  }
+  args.collect()
+}
+
+export const integer: FieldParser<'integer'> = async (args) => {
+  if (!validate(args, args.value)) {
+    return
+  }
+  args.collect()
+}
+
+export const timestamp: FieldParser<'timestamp'> = async (args) => {
+  if (typeof args.value === 'string') {
+    if (args.value === 'now') {
+      // TODO: + 1s + 10s etc
+      args.value = Date.now()
+    } else {
+      const d = new Date(args.value)
+      args.value = d.valueOf()
+      if (isNaN(args.value)) {
+        args.error(ParseError.incorrectFormat)
+        return
+      }
+    }
+  }
+  if (!validateNumber(args, args.value)) {
+    return
+  }
+  args.collect()
+}

package/src/set/fields/object.ts

@@ -0,0 +1,30 @@
+import { ParseError } from '../../error'
+import { FieldParser } from '../../walker'
+
+export const object: FieldParser<'object'> = async (args) => {
+  if (typeof args.value !== 'object') {
+    args.error(ParseError.incorrectFormat)
+    return
+  }
+  const isArray = Array.isArray(args.value)
+  if (isArray) {
+    args.error(ParseError.incorrectFormat)
+    return
+  }
+  args.collect()
+  return args
+}
+
+export const record: FieldParser<'record'> = async (args) => {
+  if (typeof args.value !== 'object') {
+    args.error(ParseError.incorrectFormat)
+    return
+  }
+  const isArray = Array.isArray(args.value)
+  if (isArray) {
+    args.error(ParseError.incorrectFormat)
+    return
+  }
+  args.collect()
+  return args
+}

package/src/set/fields/references.ts

@@ -0,0 +1,114 @@
+import { ParseError } from '../../error'
+import { 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]
+}
+
+export const reference: FieldParser<'reference'> = async (args) => {
+  // TODO: setting an object here , handling $alias (both async hooks)
+
+  // block if path contains $remove
+
+  if (!isValidId(args.schema, args.value)) {
+    args.error(ParseError.incorrectFormat)
+    return
+  }
+
+  if ('allowedTypes' in args.fieldSchema) {
+    const prefix = args.value.slice(0, 2)
+    const targetType = args.schema.prefixToTypeMapping[prefix]
+    let typeMatches = false
+    for (const t of args.fieldSchema.allowedTypes) {
+      if (typeof t === 'string') {
+        if (t === targetType) {
+          typeMatches = true
+          break
+        }
+      } else {
+        if (t.type && t.type === targetType) {
+          typeMatches = true
+          if (t.$filter) {
+            // TODO: ASYNC 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) {
+      args.error(ParseError.referenceIsIncorrectType)
+      return
+    }
+  }
+
+  args.collect()
+}
+
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,199 @@
+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()
+}
+
+async function next<T>(args: ArgsClass<T>, key: string): Promise<any> {
+  const valueArgs = args.create({
+    key,
+    value: args.value[key],
+    skipCollection: true,
+  })
+  await valueArgs.parse()
+  return valueArgs.value
+}
+
+export const text: FieldParser<'text'> = async (args) => {
+  const value = args.value
+  if (value !== null && typeof value === 'object') {
+    args.stop()
+    const result: any = {}
+    for (const key in value) {
+      if (key === '$value') {
+        const nValue = await next(args, key)
+        if (typeof nValue.value === 'object') {
+          deepMerge(result, nValue.value)
+        }
+      } else if (key === '$default') {
+        result.$default = await next(args, key)
+      } else if (args.schema.languages.includes(<BasedSchemaLanguage>key)) {
+        if (value[key] && typeof value[key] === 'object') {
+          for (const k in value[key]) {
+            if (k === '$value') {
+              if (!validateString(args, value[key].$value)) {
+                args.create({ key }).error(ParseError.incorrectFormat)
+              } else {
+                result[key] = value[key].$value
+              }
+            } else if (k === '$default') {
+              if (!validateString(args, value[key].$default)) {
+                args.create({ key }).error(ParseError.incorrectFormat)
+              } else {
+                setByPath(result, ['$default', key], value[key].$default)
+              }
+            } else {
+              args
+                .create({ path: [...args.path, key, k] })
+                .error(ParseError.fieldDoesNotExist)
+            }
+          }
+        } else {
+          if (!validateString(args, args.value[key])) {
+            args.error(ParseError.incorrectFormat)
+            return
+          }
+          result[key] = args.value[key]
+        }
+      } else {
+        args.create({ key }).error(ParseError.languageNotSupported)
+      }
+    }
+    args.collect(result)
+    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.value = {
+    [args.target.$language]: value,
+  }
+
+  args.collect()
+}