@based/schema 0.0.16 → 1.0.2

package/src/set/parseDefaultAndValue.ts

@@ -1,54 +0,0 @@
-import { BasedSchemaFields } from '../types'
-import { Parser } from './types'
-import { error, ParseError } from './error'
-import parsers from './parsers'
-
-export const parseValueAndDefault: Parser<keyof BasedSchemaFields> = async (
-  path,
-  value,
-  fieldSchema,
-  typeSchema,
-  target,
-  handlers,
-  noCollect
-): Promise<boolean> => {
-  let handled = false
-  if (typeof value === 'object') {
-    const typeDef = fieldSchema.type ?? ('enum' in fieldSchema ? 'enum' : '')
-    const parse = parsers[typeDef]
-    if (value.$value !== undefined) {
-      // TODO: for errors handle path a bit smarter...
-      await parse(
-        path,
-        value.$value,
-        fieldSchema,
-        typeSchema,
-        target,
-        handlers,
-        true
-      )
-      handled = true
-    }
-    if (value.$default !== undefined) {
-      if (value.$value !== undefined) {
-        error(handlers, ParseError.valueAndDefault, path)
-      }
-      console.info('->', path, 'go')
-      await parse(
-        path,
-        value.$default,
-        fieldSchema,
-        typeSchema,
-        target,
-        handlers,
-        true
-      )
-      handled = true
-    }
-  }
-  if (handled && !noCollect) {
-    console.log('collect?')
-    handlers.collect({ path, value, typeSchema, fieldSchema, target })
-  }
-  return handled
-}

package/src/set/parsers.ts

@@ -1,20 +0,0 @@
-import { Parsers } from './types'
-import * as references from './references'
-import * as collections from './collections'
-import * as number from './number'
-import * as string from './string'
-
-import { enumParser, boolean, cardinality, json } from './rest'
-
-const parsers: Parsers = {
-  ...string,
-  ...references,
-  ...collections,
-  ...number,
-  enum: enumParser,
-  boolean,
-  cardinality,
-  json,
-}
-
-export default parsers

package/src/set/references.ts

@@ -1,113 +0,0 @@
-import { Parser } from './types'
-import { error, ParseError } from './error'
-
-export const reference: Parser<'reference'> = async (
-  path,
-  value,
-  fieldSchema,
-  typeSchema,
-  target,
-  handlers,
-  noCollect
-) => {
-  // $no root
-  // prob pass these as options
-  // value .default
-  // $value
-
-  if (typeof value !== 'string') {
-    error(handlers, ParseError.incorrectFormat, path)
-  }
-
-  if ('allowedTypes' in fieldSchema) {
-    const prefix = value.slice(0, 2)
-    const targetType = target.schema.prefixToTypeMapping[prefix]
-    if (!targetType) {
-      error(handlers, ParseError.referenceIsIncorrectType, path)
-      return
-    }
-    let typeMatches = false
-    for (const t of fieldSchema.allowedTypes) {
-      if (typeof t === 'string') {
-        if (t === targetType) {
-          typeMatches = true
-          break
-        }
-      } else {
-        if (t.type && t.type === targetType) {
-          typeMatches = true
-          if (t.$filter) {
-            if (!(await handlers.referenceFilterCondition(value, t.$filter))) {
-              error(handlers, ParseError.referenceIsIncorrectType, path)
-              return
-            }
-          }
-        } else if (!t.type && t.$filter) {
-          if (!(await handlers.referenceFilterCondition(value, t.$filter))) {
-            error(handlers, ParseError.referenceIsIncorrectType, path)
-            return
-          }
-        }
-      }
-    }
-    if (typeMatches === false) {
-      error(handlers, ParseError.referenceIsIncorrectType, path)
-      return
-    }
-  }
-  if (!noCollect) {
-    handlers.collect({ path, value, typeSchema, fieldSchema, target })
-  }
-}
-
-export const references: Parser<'references'> = async (
-  path,
-  value,
-  fieldSchema,
-  typeSchema,
-  target,
-  handlers,
-  noCollect
-) => {
-  // default
-  // $no root
-  if (Array.isArray(value)) {
-    await Promise.all(
-      value.map((v, i) => {
-        return reference(
-          [...path, i],
-          v,
-          // not nice slow
-          { ...fieldSchema, type: 'reference' },
-          typeSchema,
-          target,
-          handlers,
-          true
-        )
-      })
-    )
-    value = { $value: value }
-  } else if (typeof value === 'object') {
-    if (value.$add) {
-      await Promise.all(
-        value.$add.map((v, i) => {
-          return reference(
-            [...path, '$add', i],
-            v,
-            // not nice slow
-            { ...fieldSchema, type: 'reference' },
-            typeSchema,
-            target,
-            handlers,
-            true
-          )
-        })
-      )
-    }
-  } else {
-    error(handlers, ParseError.incorrectFormat, path)
-  }
-  if (!noCollect) {
-    handlers.collect({ path, value, typeSchema, fieldSchema, target })
-  }
-}

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
-//   )
-// }