@based/schema 0.0.5 → 0.0.7

package/src/set/references.ts

@@ -0,0 +1,107 @@
+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(path, ParseError.incorrectFormat)
+  }
+
+  if ('allowedTypes' in fieldSchema) {
+    const prefix = value.slice(0, 2)
+    const targetType = target.schema.prefixToTypeMapping[prefix]
+    if (!targetType) {
+      error(path, ParseError.referenceIsIncorrectType)
+    }
+    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(path, ParseError.referenceIsIncorrectType)
+            }
+          }
+        } else if (!t.type && t.$filter) {
+          if (!(await handlers.referenceFilterCondition(value, t.$filter))) {
+            error(path, ParseError.referenceIsIncorrectType)
+          }
+        }
+      }
+    }
+    if (typeMatches === false) {
+      error(path, ParseError.referenceIsIncorrectType)
+    }
+  }
+  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
+          )
+        })
+      )
+    }
+  }
+  if (!noCollect) {
+    handlers.collect({ path, value, typeSchema, fieldSchema, target })
+  }
+}

package/src/set/rest.ts

@@ -0,0 +1,83 @@
+import { Parser } from './types'
+import { deepEqual } from '@saulx/utils'
+import { hashObjectIgnoreKeyOrder, hash } from '@saulx/hash'
+import { error, ParseError } from './error'
+
+export const cardinality: Parser<'cardinality'> = async (
+  path,
+  value,
+  fieldSchema,
+  typeSchema,
+  target,
+  handlers
+) => {
+  if (value && typeof value === 'object') {
+    value = hashObjectIgnoreKeyOrder(value).toString(16)
+  } else {
+    value = hash(value).toString(16)
+  }
+  handlers.collect({ path, value, typeSchema, fieldSchema, target })
+}
+
+export const boolean: Parser<'boolean'> = async (
+  path,
+  value,
+  fieldSchema,
+  typeSchema,
+  target,
+  handlers,
+  noCollect
+) => {
+  if (typeof value !== 'boolean') {
+    error(path, ParseError.incorrectFormat)
+  }
+  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
+  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(path, ParseError.incorrectFormat)
+}
+
+export const json: Parser<'json'> = async (
+  path,
+  value,
+  fieldSchema,
+  typeSchema,
+  target,
+  handlers,
+  noCollect
+) => {
+  try {
+    const parsedValue = JSON.stringify(value)
+    if (!noCollect) {
+      handlers.collect({
+        path,
+        value: parsedValue,
+        typeSchema,
+        fieldSchema,
+        target,
+      })
+    }
+  } catch (err) {
+    throw err(path, ParseError.incorrectFormat)
+  }
+}

package/src/set/string.ts

@@ -0,0 +1,184 @@
+import { Parser } from './types'
+import { error, ParseError } from './error'
+import { BasedSchemaFieldString, BasedSchemaFieldText } from '../types'
+import validators from 'validator'
+
+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 = (
+  path: (string | number)[],
+  value: string,
+  fieldSchema: BasedSchemaFieldText | BasedSchemaFieldString
+) => {
+  if (typeof value !== 'string') {
+    error(path, ParseError.incorrectFormat)
+  }
+  if (fieldSchema.minLength && value.length < fieldSchema.minLength) {
+    error(path, ParseError.subceedsMinimum)
+  }
+  if (fieldSchema.maxLength && value.length > fieldSchema.maxLength) {
+    error(path, ParseError.exceedsMaximum)
+  }
+  if (fieldSchema.pattern) {
+    const re = new RegExp(fieldSchema.pattern)
+    if (!re.test(value)) {
+      error(path, ParseError.incorrectFormat)
+    }
+  }
+  if (fieldSchema.format && !formatPatterns[fieldSchema.format](value)) {
+    error(path, ParseError.incorrectFormat)
+  }
+}
+
+export const string: Parser<'string'> = async (
+  path,
+  value,
+  fieldSchema,
+  typeSchema,
+  target,
+  handlers,
+  noCollect
+) => {
+  validate(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(path, value, fieldSchema)
+    if (!noCollect) {
+      handlers.collect({
+        path,
+        value: { [target.$language]: value },
+        typeSchema,
+        fieldSchema,
+        target,
+      })
+    }
+    return
+  }
+
+  if (valueType !== 'object') {
+    error(path, ParseError.incorrectFormat)
+  }
+
+  for (const key in value) {
+    const newPath = [...path, key]
+
+    if (typeof value[key] === 'object') {
+      if (value[key].$value) {
+        text(
+          [...path, key, '$value'],
+          value[key].$value,
+          fieldSchema,
+          typeSchema,
+          target,
+          handlers,
+          true
+        )
+      }
+
+      // if (value[key].$default) {
+      // }
+
+      if (!noCollect) {
+        handlers.collect({
+          path: newPath,
+          value: null,
+          typeSchema,
+          fieldSchema,
+          target,
+        })
+      }
+      continue
+    }
+
+    validate(newPath, value[key], fieldSchema)
+
+    if (!noCollect) {
+      handlers.collect({
+        path: newPath,
+        value: value[key],
+        typeSchema,
+        fieldSchema,
+        target,
+      })
+    }
+  }
+}

package/src/set/types.ts

@@ -0,0 +1,20 @@
+import {
+  BasedSchemaType,
+  BasedSetHandlers,
+  BasedSetTarget,
+  BasedSchemaFields,
+} from '../types'
+
+export type Parser<K extends keyof BasedSchemaFields> = (
+  path: (string | number)[],
+  value: any,
+  fieldSchema: BasedSchemaFields[K],
+  typeSchema: BasedSchemaType,
+  target: BasedSetTarget,
+  handlers: BasedSetHandlers,
+  noCollect?: boolean
+) => Promise<void>
+
+export type Parsers = {
+  [Key in keyof BasedSchemaFields]: Parser<Key>
+}

package/src/types.ts

@@ -28,14 +28,13 @@ export type BasedSchemaFieldType =
   | 'string'
   | 'boolean'
   | 'number'
-  | 'float'
   | 'json'
   | 'integer'
   | 'timestamp'
   | 'reference'
   | 'references'
   | 'text'
-  | 'hyperloglog'
+  | 'cardinality'
 
 export const isCollection = (type: string): boolean => {
   return type === 'array' || type === 'object' || type === 'record'
@@ -58,12 +57,17 @@ export type BasedSchemaContentMediaType =
   | string
 
 export type BasedSchemaFieldShared = {
+  hooks?:
+    | { interval?: number; hook: string }
+    | { interval?: number; hook: string }[]
+
   type?: BasedSchemaFieldType
   $id?: string
   $schema?: string
   isRequired?: boolean
   title?: string
   description?: string
+  index?: number // Determines the order of fields
   readOnly?: boolean
   writeOnly?: boolean
   $comment?: string
@@ -79,25 +83,92 @@ export type BasedSchemaFieldShared = {
 }
 
 // -------------- Primitive ---------------
-export type BasedSchemaFieldString = {
-  type: 'string'
+
+export type BasedSchemaStringShared = {
   minLength?: number
   maxLength?: number
   contentMediaEncoding?: string // base64
   contentMediaType?: BasedSchemaContentMediaType
   pattern?: BasedSchemaPattern
-  format?: 'email' | 'hostname' | 'ipv4' | 'ipv6' | 'uuid' | 'uri'
+  format?:
+    | 'email'
+    | 'URL'
+    | 'MACAddress'
+    | 'IP'
+    | 'IPRange'
+    | 'FQDN'
+    | 'IBAN'
+    | 'BIC'
+    | 'alpha'
+    | 'alphaLocales'
+    | 'alphanumeric'
+    | 'alphanumericLocales'
+    | 'passportNumber'
+    | 'port'
+    | 'lowercase'
+    | 'uppercase'
+    | 'ascii'
+    | 'semVer'
+    | 'surrogatePair'
+    | 'IMEI'
+    | 'hexadecimal'
+    | 'octal'
+    | 'hexColor'
+    | 'rgbColor'
+    | 'HSL'
+    | 'ISRC'
+    | 'MD5'
+    | 'JWT'
+    | 'UUID'
+    | 'luhnNumber'
+    | 'creditCard'
+    | 'identityCard'
+    | 'EAN'
+    | 'ISIN'
+    | 'ISBN'
+    | 'ISSN'
+    | 'mobilePhone'
+    | 'mobilePhoneLocales'
+    | 'postalCode'
+    | 'postalCodeLocales'
+    | 'ethereumAddress'
+    | 'currency'
+    | 'btcAddress'
+    | 'ISO6391'
+    | 'ISO8601'
+    | 'RFC3339'
+    | 'ISO31661Alpha2'
+    | 'ISO31661Alpha3'
+    | 'ISO4217'
+    | 'base32'
+    | 'base58'
+    | 'base64'
+    | 'dataURI'
+    | 'magnetURI'
+    | 'mimeType'
+    | 'latLong'
+    | 'slug'
+    | 'strongPassword'
+    | 'taxID'
+    | 'licensePlate'
+    | 'VAT'
+}
+
+export type BasedSchemaFieldString = {
+  type: 'string'
+
   // maybe add some more? e.g. phone
-} & BasedSchemaFieldShared
+} & BasedSchemaFieldShared &
+  BasedSchemaStringShared
 
 export type BasedSchemaFieldEnum = {
-  enum: any[] // this changes behaviour pretty extreme
-  // important to type as well because we want to enum based on the type e.g. for references
+  enum: any[]
 } & BasedSchemaFieldShared
 
-export type BasedSchemaFieldConst = {
-  const: any
-} & BasedSchemaFieldShared
+// TODO: check if we want this later
+// export type BasedSchemaFieldConst = {
+//   const: any
+// } & BasedSchemaFieldShared
 
 type NumberDefaults = {
   multipleOf?: number
@@ -111,8 +182,8 @@ export type BasedSchemaFieldNumber = NumberDefaults & {
   type: 'number'
 }
 
-export type BasedSchemaFieldHyperLogLog = {
-  type: 'hyperloglog'
+export type BasedSchemaFieldCardinality = {
+  type: 'cardinality'
 }
 
 export type BasedSchemaFieldInteger = NumberDefaults & {
@@ -146,12 +217,8 @@ export type BasedSchemaFieldPrimitive =
 export type BasedSchemaFieldText = {
   type: 'text'
   required?: BasedSchemaLanguage[]
-  contentMediaType?: BasedSchemaContentMediaType
-  minLength?: number
-  maxLength?: number
-  contentMediaEncoding?: string // base64
-  pattern?: BasedSchemaPattern
-} & BasedSchemaFieldShared
+} & BasedSchemaFieldShared &
+  BasedSchemaStringShared
 
 export type BasedSchemaFieldObject = {
   type: 'object'
@@ -208,13 +275,31 @@ export type BasedSchemaField =
   | BasedSchemaFieldPrimitive
   | BasedSchemaFieldReference
   | BasedSchemaFieldReferences
-  | BasedSchemaFieldHyperLogLog
+  | BasedSchemaFieldCardinality
   | {
       type?: BasedSchemaFieldType
       isRequired?: boolean // our own
       $ref: string // to mimic json schema will just load it in place (so only for setting)
     }
 
+export type BasedSchemaFields = {
+  enum: BasedSchemaFieldEnum
+  array: BasedSchemaFieldArray
+  object: BasedSchemaFieldObject
+  set: BasedSchemaFieldSet
+  record: BasedSchemaFieldRecord
+  string: BasedSchemaFieldString
+  boolean: BasedSchemaFieldBoolean
+  number: BasedSchemaFieldNumber
+  json: BasedSchemaFieldJSON
+  integer: BasedSchemaFieldInteger
+  timestamp: BasedSchemaFieldTimeStamp
+  reference: BasedSchemaFieldReference
+  references: BasedSchemaFieldReferences
+  text: BasedSchemaFieldText
+  cardinality: BasedSchemaFieldCardinality
+}
+
 export type BasedSchemaType = {
   fields: {
     [name: string]: BasedSchemaField

package/test/setWalker.ts

@@ -6,6 +6,12 @@ const schema: BasedSchema = {
     bla: {
       prefix: 'bl',
       fields: {
+        visits: {
+          type: 'cardinality',
+        },
+        blub: {
+          type: 'number',
+        },
         snurp: {
           type: 'array',
           values: {
@@ -141,6 +147,14 @@ test.serial('collect correctly', async (t) => {
     schema,
     {
       $id: 'bl1',
+      visits: {
+        flap: true,
+        snurp: false,
+        ua: '123435',
+      },
+      blub: {
+        $increment: 1,
+      },
       bla: false,
       time: now, // do more later
       setje: [1, 2, 3],
@@ -194,6 +208,8 @@ test.serial('collect correctly', async (t) => {
   )
 
   const result = [
+    { path: ['visits'], value: '3a9009740ee' },
+    { path: ['blub'], value: { $increment: 1 } },
     { path: ['bla'], value: false },
     { path: ['time'], value: now },
     { path: ['form', 'lastName'], value: 'de beer' },
@@ -201,21 +217,21 @@ test.serial('collect correctly', async (t) => {
     { path: ['form', 'snurp'], value: 'blx12' },
     { path: ['form', 'things'], value: 2 },
     { path: ['form', 'password'], value: 'mypassword!' },
+    { path: ['snurp', 0, 'x', 0], value: 1 },
+    { path: ['snurp', 0, 'x', 1], value: 2 },
+    { path: ['snurp', 0, 'x', 2], value: 3 },
+    { path: ['form', 'bla'], value: { $value: ['bl123', 'bl234'] } },
+    { path: ['form', 'blab'], value: { $add: ['bl456'] } },
     {
       path: ['snurpArray'],
       value: { $assign: { $idx: 0, $value: 100 } },
     },
+    { path: ['setje'], value: { $value: [1, 2, 3] } },
+    { path: ['form', 'blub'], value: { $value: ['x'] } },
     {
       path: ['specialArray'],
       value: { $insert: { $value: ['a', 'b', 'c'], $idx: 0 } },
     },
-    { path: ['snurp', 0, 'x', 0], value: 1 },
-    { path: ['snurp', 0, 'x', 1], value: 2 },
-    { path: ['snurp', 0, 'x', 2], value: 3 },
-    { path: ['form', 'bla'], value: { $value: ['bl123', 'bl234'] } },
-    { path: ['form', 'blab'], value: { $add: ['bl456'] } },
-    { path: ['setje'], value: { $value: [1, 2, 3] } },
-    { path: ['form', 'blub'], value: { $value: ['x'] } },
   ]
 
   t.deepEqual(results, result)

package/src/set/handleError.ts

@@ -1,15 +0,0 @@
-export const createError = (
-  path: (number | string)[],
-  fromType: string,
-  fieldType: string,
-  value: any,
-  fieldDoesNotExist?: string,
-  msg?: string
-): Error => {
-  const err = new Error()
-  return new Error(
-    `Type: "${fromType}" Field: "${path.join(
-      '.'
-    )}" is not a valid value for ${fieldType}`
-  )
-}