@based/schema 0.0.4 → 0.0.6

package/dist/set/string.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.text = exports.string = void 0;
+const error_1 = require("./error");
+const validator_1 = __importDefault(require("validator"));
+const formatPatterns = {
+    email: validator_1.default.isEmail,
+    URL: validator_1.default.isURL,
+    MACAddress: validator_1.default.isMACAddress,
+    IP: validator_1.default.isIP,
+    IPRange: validator_1.default.isIPRange,
+    FQDN: validator_1.default.isFQDN,
+    IBAN: validator_1.default.isIBAN,
+    BIC: validator_1.default.isBIC,
+    alpha: validator_1.default.isAlpha,
+    alphaLocales: validator_1.default.isAlphaLocales,
+    alphanumeric: validator_1.default.isAlphanumeric,
+    alphanumericLocales: validator_1.default.isAlphanumericLocales,
+    passportNumber: validator_1.default.isPassportNumber,
+    port: validator_1.default.isPort,
+    lowercase: validator_1.default.isLowercase,
+    uppercase: validator_1.default.isUppercase,
+    ascii: validator_1.default.isAscii,
+    semVer: validator_1.default.isSemVer,
+    surrogatePair: validator_1.default.isSurrogatePair,
+    IMEI: validator_1.default.isIMEI,
+    hexadecimal: validator_1.default.isHexadecimal,
+    octal: validator_1.default.isOctal,
+    hexColor: validator_1.default.isHexColor,
+    rgbColor: validator_1.default.isRgbColor,
+    HSL: validator_1.default.isHSL,
+    ISRC: validator_1.default.isISRC,
+    MD5: validator_1.default.isMD5,
+    JWT: validator_1.default.isJWT,
+    UUID: validator_1.default.isUUID,
+    luhnNumber: validator_1.default.isLuhnNumber,
+    creditCard: validator_1.default.isCreditCard,
+    identityCard: validator_1.default.isIdentityCard,
+    EAN: validator_1.default.isEAN,
+    ISIN: validator_1.default.isISIN,
+    ISBN: validator_1.default.isISBN,
+    ISSN: validator_1.default.isISSN,
+    mobilePhone: validator_1.default.isMobilePhone,
+    mobilePhoneLocales: validator_1.default.isMobilePhoneLocales,
+    postalCode: validator_1.default.isPostalCode,
+    postalCodeLocales: validator_1.default.isPostalCodeLocales,
+    ethereumAddress: validator_1.default.isEthereumAddress,
+    currency: validator_1.default.isCurrency,
+    btcAddress: validator_1.default.isBtcAddress,
+    ISO6391: validator_1.default.isISO6391,
+    ISO8601: validator_1.default.isISO8601,
+    RFC3339: validator_1.default.isRFC3339,
+    ISO31661Alpha2: validator_1.default.isISO31661Alpha2,
+    ISO31661Alpha3: validator_1.default.isISO31661Alpha3,
+    ISO4217: validator_1.default.isISO4217,
+    base32: validator_1.default.isBase32,
+    base58: validator_1.default.isBase58,
+    base64: validator_1.default.isBase64,
+    dataURI: validator_1.default.isDataURI,
+    magnetURI: validator_1.default.isMagnetURI,
+    mimeType: validator_1.default.isMimeType,
+    latLong: validator_1.default.isLatLong,
+    slug: validator_1.default.isSlug,
+    strongPassword: validator_1.default.isStrongPassword,
+    taxID: validator_1.default.isTaxID,
+    licensePlate: validator_1.default.isLicensePlate,
+    VAT: validator_1.default.isVAT,
+};
+const validate = (path, value, fieldSchema) => {
+    if (typeof value !== 'string') {
+        (0, error_1.error)(path, error_1.ParseError.incorrectFormat);
+    }
+    if (fieldSchema.minLength && value.length < fieldSchema.minLength) {
+        (0, error_1.error)(path, error_1.ParseError.subceedsMinimum);
+    }
+    if (fieldSchema.maxLength && value.length > fieldSchema.maxLength) {
+        (0, error_1.error)(path, error_1.ParseError.exceedsMaximum);
+    }
+    if (fieldSchema.pattern) {
+        const re = new RegExp(fieldSchema.pattern);
+        if (!re.test(value)) {
+            (0, error_1.error)(path, error_1.ParseError.incorrectFormat);
+        }
+    }
+    if (fieldSchema.format && !formatPatterns[fieldSchema.format](value)) {
+        (0, error_1.error)(path, error_1.ParseError.incorrectFormat);
+    }
+};
+const string = async (path, value, fieldSchema, typeSchema, target, handlers) => {
+    validate(path, value, fieldSchema);
+    handlers.collect({ path, value, typeSchema, fieldSchema, target });
+};
+exports.string = string;
+const text = async (path, value, fieldSchema, typeSchema, target, handlers) => {
+    const valueType = typeof value;
+    if (target.$language && valueType === 'string') {
+        validate(path, value, fieldSchema);
+        handlers.collect({
+            path,
+            value: { [target.$language]: value },
+            typeSchema,
+            fieldSchema,
+            target,
+        });
+        return;
+    }
+    if (valueType !== 'object') {
+        (0, error_1.error)(path, error_1.ParseError.incorrectFormat);
+    }
+    for (const key in value) {
+        const newPath = [...path, key];
+        if (typeof value[key] === 'object' && value[key].$delete === true) {
+            handlers.collect({
+                path: newPath,
+                value: null,
+                typeSchema,
+                fieldSchema,
+                target,
+            });
+            continue;
+        }
+        validate(newPath, value[key], fieldSchema);
+        handlers.collect({
+            path: newPath,
+            value: value[key],
+            typeSchema,
+            fieldSchema,
+            target,
+        });
+    }
+};
+exports.text = text;
+//# sourceMappingURL=string.js.map

package/dist/set/string.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.js","sourceRoot":"","sources":["../../src/set/string.ts"],"names":[],"mappings":"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"}

package/dist/set/types.d.ts

@@ -0,0 +1,5 @@
+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) => Promise<void>;
+export type Parsers = {
+    [Key in keyof BasedSchemaFields]: Parser<Key>;
+};

package/dist/{deepPartial.js → set/types.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=deepPartial.js.map
+//# sourceMappingURL=types.js.map

package/dist/set/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/set/types.ts"],"names":[],"mappings":""}

package/dist/types.d.ts

@@ -4,19 +4,27 @@ export type AllowedTypes = (string | {
     type?: string;
     $filter: any | any[];
 })[];
-export type BasedSchemaFieldType = 'array' | 'object' | 'record' | 'set' | 'string' | 'boolean' | 'number' | 'float' | 'json' | 'integer' | 'timestamp' | 'reference' | 'references' | 'text';
+export type BasedSchemaFieldType = 'array' | 'object' | 'record' | 'set' | 'string' | 'boolean' | 'number' | 'json' | 'integer' | 'timestamp' | 'reference' | 'references' | 'text' | 'cardinality';
 export declare const isCollection: (type: string) => boolean;
 export type BasedSchemaPattern = string;
 export type BasedSchemaLanguage = Language;
 export type BasedSchemaTypePrefix = string;
 export type BasedSchemaContentMediaType = 'text/html' | 'text/plain' | 'text/markdown' | 'image/png' | 'image/jpeg' | 'video/mp4' | 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;
     readOnly?: boolean;
     writeOnly?: boolean;
     $comment?: string;
@@ -27,21 +35,20 @@ export type BasedSchemaFieldShared = {
         [key: string]: BasedSchemaField;
     };
 };
-export type BasedSchemaFieldString = {
-    type: 'string';
+export type BasedSchemaStringShared = {
     minLength?: number;
     maxLength?: number;
     contentMediaEncoding?: string;
     contentMediaType?: BasedSchemaContentMediaType;
     pattern?: BasedSchemaPattern;
-    format?: 'email' | 'hostname' | 'ipv4' | 'ipv6' | 'uuid' | 'uri';
-} & BasedSchemaFieldShared;
+    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';
+} & BasedSchemaFieldShared & BasedSchemaStringShared;
 export type BasedSchemaFieldEnum = {
     enum: any[];
 } & BasedSchemaFieldShared;
-export type BasedSchemaFieldConst = {
-    const: any;
-} & BasedSchemaFieldShared;
 type NumberDefaults = {
     multipleOf?: number;
     minimum?: number;
@@ -52,8 +59,8 @@ type NumberDefaults = {
 export type BasedSchemaFieldNumber = NumberDefaults & {
     type: 'number';
 };
-export type BasedSchemaFieldHyperLogLog = {
-    type: 'hyperloglog';
+export type BasedSchemaFieldCardinality = {
+    type: 'cardinality';
 };
 export type BasedSchemaFieldInteger = NumberDefaults & {
     type: 'integer';
@@ -71,12 +78,7 @@ export type BasedSchemaFieldPrimitive = BasedSchemaFieldString | BasedSchemaFiel
 export type BasedSchemaFieldText = {
     type: 'text';
     required?: BasedSchemaLanguage[];
-    contentMediaType?: BasedSchemaContentMediaType;
-    minLength?: number;
-    maxLength?: number;
-    contentMediaEncoding?: string;
-    pattern?: BasedSchemaPattern;
-} & BasedSchemaFieldShared;
+} & BasedSchemaFieldShared & BasedSchemaStringShared;
 export type BasedSchemaFieldObject = {
     type: 'object';
     properties: {
@@ -111,11 +113,28 @@ export type BasedSchemaFieldReferences = {
     };
     allowedTypes?: AllowedTypes;
 } & BasedSchemaFieldShared;
-export type BasedSchemaField = BasedSchemaFieldEnumerable | BasedSchemaFieldPrimitive | BasedSchemaFieldReference | BasedSchemaFieldReferences | BasedSchemaFieldHyperLogLog | {
+export type BasedSchemaField = BasedSchemaFieldEnumerable | BasedSchemaFieldPrimitive | BasedSchemaFieldReference | BasedSchemaFieldReferences | BasedSchemaFieldCardinality | {
     type?: BasedSchemaFieldType;
     isRequired?: boolean;
     $ref: string;
 };
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@based/schema",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "license": "MIT",
   "main": "dist/index.js",
   "scripts": {
@@ -11,6 +11,8 @@
   },
   "sideEffects": false,
   "dependencies": {
+    "validator": "^13.9.0",
+    "@saulx/hash": "^2.0.0",
     "@saulx/utils": "^3.2.2"
   },
   "ava": {

package/src/set/collections.ts

@@ -0,0 +1,246 @@
+import { Parser } from './types'
+import { error, ParseError } from './error'
+import { fieldWalker } from '.'
+
+export const set: Parser<'set'> = async (
+  path,
+  value,
+  fieldSchema,
+  typeSchema,
+  target,
+  handlers
+) => {
+  const q: Promise<void>[] = []
+  const fieldDef = fieldSchema.items
+  if (Array.isArray(value)) {
+    const handlerNest = {
+      ...handlers,
+      collect: ({ value }) => {
+        parsedArray.push(value)
+      },
+    }
+    const parsedArray = []
+    for (let i = 0; i < value.length; i++) {
+      q.push(
+        fieldWalker(
+          [...path, i],
+          value[i],
+          fieldDef,
+          typeSchema,
+          target,
+          handlerNest
+        )
+      )
+    }
+    await Promise.all(q)
+    handlers.collect({
+      path,
+      value: { $value: parsedArray },
+      typeSchema,
+      fieldSchema,
+      target,
+    })
+  } else {
+    const handlerNest = {
+      ...handlers,
+      collect: () => {},
+    }
+    if (value.$add) {
+      for (let i = 0; i < value.$add.length; i++) {
+        q.push(
+          fieldWalker(
+            [...path, '$add', i],
+            value.$add[i],
+            fieldDef,
+            typeSchema,
+            target,
+            handlerNest
+          )
+        )
+      }
+    }
+    if (value.$delete) {
+      for (let i = 0; i < value.$add.length; i++) {
+        q.push(
+          fieldWalker(
+            [...path, '$delete', i],
+            value.$delete[i],
+            fieldDef,
+            typeSchema,
+            target,
+            handlerNest
+          )
+        )
+      }
+    }
+    await Promise.all(q)
+    handlers.collect({ path, value, typeSchema, fieldSchema, target })
+  }
+}
+
+export const object: Parser<'object'> = async (
+  path,
+  value,
+  fieldSchema,
+  typeSchema,
+  target,
+  handlers
+) => {
+  if (typeof value !== 'object') {
+    error(path, ParseError.incorrectFormat)
+  }
+  const isArray = Array.isArray(value)
+  if (isArray) {
+    error(path, ParseError.incorrectFormat)
+  }
+  const q: Promise<void>[] = []
+  for (const key in value) {
+    const propDef = fieldSchema.properties[key]
+    if (!propDef) {
+      error([...path, key], ParseError.fieldDoesNotExist)
+    }
+    q.push(
+      fieldWalker(
+        [...path, key],
+        value[key],
+        propDef,
+        typeSchema,
+        target,
+        handlers
+      )
+    )
+  }
+  await Promise.all(q)
+}
+
+export const array: Parser<'array'> = async (
+  path,
+  value,
+  fieldSchema,
+  typeSchema,
+  target,
+  handlers
+) => {
+  const isArray = Array.isArray(value)
+  if (typeof value === 'object' && !isArray) {
+    if (value.$insert) {
+      if (
+        typeof value.$insert !== 'object' ||
+        value.$insert.$idx === undefined
+      ) {
+        error([...path, '$insert'], ParseError.incorrectFormat)
+      } else {
+        const nestedHandler = {
+          ...handlers,
+          collect: () => {},
+        }
+        const q: Promise<void>[] = []
+        if (Array.isArray(value.$insert.$value)) {
+          for (let i = 0; i < value.$insert.$value.length; i++) {
+            q.push(
+              fieldWalker(
+                [...path, 'insert', i],
+                value.$insert.$value[i],
+                fieldSchema.values,
+                typeSchema,
+                target,
+                nestedHandler
+              )
+            )
+          }
+        } else {
+          q.push(
+            fieldWalker(
+              [...path, '$insert'],
+              value.$insert.$value,
+              fieldSchema.values,
+              typeSchema,
+              target,
+              nestedHandler
+            )
+          )
+        }
+        await Promise.all(q)
+      }
+    }
+    if (value.$remove && value.$remove.$idx === undefined) {
+      error([...path, '$remove'], ParseError.incorrectFormat)
+    }
+    if (value.$push) {
+      const q: Promise<void>[] = []
+      const nestedHandler = {
+        ...handlers,
+        collect: () => {},
+      }
+      if (Array.isArray(value.$push)) {
+        for (let i = 0; i < value.$push.length; i++) {
+          q.push(
+            fieldWalker(
+              [...path, i],
+              value.$push[i],
+              fieldSchema.values,
+              typeSchema,
+              target,
+              nestedHandler
+            )
+          )
+        }
+      } else {
+        q.push(
+          fieldWalker(
+            [...path, '$push'],
+            value.$push,
+            fieldSchema.values,
+            typeSchema,
+            target,
+            nestedHandler
+          )
+        )
+      }
+      await Promise.all(q)
+    }
+    if (value.$assign) {
+      if (
+        typeof value.$assign !== 'object' ||
+        value.$assign.$idx === undefined
+      ) {
+        error([...path, '$assign'], ParseError.incorrectFormat)
+      } else {
+        await fieldWalker(
+          [...path, '$assign', '$value'],
+          value.$assign.$value,
+          fieldSchema.values,
+          typeSchema,
+          target,
+          {
+            ...handlers,
+            collect: () => {},
+          }
+        )
+      }
+    }
+    handlers.collect({ path, value, typeSchema, fieldSchema, target })
+    return
+  }
+
+  if (!isArray) {
+    error(path, ParseError.incorrectFieldType)
+  }
+
+  const q: Promise<void>[] = []
+  for (let i = 0; i < value.length; i++) {
+    q.push(
+      fieldWalker(
+        [...path, i],
+        value[i],
+        fieldSchema.values,
+        typeSchema,
+        target,
+        handlers
+      )
+    )
+  }
+  await Promise.all(q)
+}
+
+export const record: Parser<'record'> = async (path, value, fieldSchema) => {}

package/src/set/error.ts

@@ -0,0 +1,17 @@
+export enum ParseError {
+  'incorrectFieldType',
+  'incorrectNodeType',
+  'exceedsMaximum',
+  'subceedsMinimum',
+  'fieldDoesNotExist',
+  'incorrectFormat',
+  'referenceIsIncorrectType',
+}
+
+export const error = (
+  path: (number | string)[],
+  error: ParseError,
+  type?: string // nice to give as option
+) => {
+  throw new Error(`Field: "${path.join('.')}" ${ParseError[error]}`)
+}

package/src/set/index.ts

@@ -5,13 +5,9 @@ import {
   BasedSchema,
   BasedSetTarget,
 } from '../types'
-import { createError } from './handleError'
+import { error, ParseError } from './error'
 import parsers from './parsers'
 
-// Collect is a pretty good place for checking if a user is allowed to set something
-// also make collect async
-// add extra function for loading required
-
 export const fieldWalker = async (
   path: (string | number)[],
   value: any,
@@ -35,13 +31,13 @@ export const fieldWalker = async (
   const typeDef = fieldSchema.type ?? ('enum' in fieldSchema ? 'enum' : '')
 
   if (!typeDef) {
-    throw createError(path, target.type, typeDef, path[path.length - 1])
+    error(path, ParseError.fieldDoesNotExist)
   }
 
   if ('customValidator' in fieldSchema) {
     const customValidator = fieldSchema.customValidator
     if (!(await customValidator(value, path, target))) {
-      throw createError(path, target.type, typeDef, value)
+      error(path, ParseError.incorrectFormat)
     }
   }
 
@@ -62,15 +58,13 @@ export const setWalker = async (
   if (value.$id) {
     type = schema.prefixToTypeMapping[value.$id.slice(0, 2)]
     if (!type) {
-      throw new Error(`Cannot find type for $id ${value.$id}`)
+      error([value.$id], ParseError.incorrectNodeType)
     }
   }
 
   if (value.type) {
     if (type && value.type !== type) {
-      throw new Error(
-        `type from "$id" ${value.$id} does not match "type" field ${value.type}`
-      )
+      error([value.$id, value.type], ParseError.incorrectNodeType)
     }
     type = value.type
   }
@@ -78,7 +72,7 @@ export const setWalker = async (
   const schemaType = schema.types[type]
 
   if (!schemaType) {
-    throw new Error(`Cannot find schema definition for type ${type}`)
+    error([type], ParseError.incorrectNodeType)
   }
 
   const target: BasedSetTarget = {
@@ -95,14 +89,10 @@ export const setWalker = async (
   const q: Promise<void>[] = []
 
   for (const key in value) {
-    if (key[0] === '$') {
-      console.info('key is operator', key)
-    } else {
+    if (key[0] !== '$') {
       const fieldSchema = schemaType.fields[key]
       if (!fieldSchema) {
-        throw new Error(
-          `Field does not exist in schema "${key}" on type "${type}"`
-        )
+        error([key], ParseError.fieldDoesNotExist)
       } else {
         q.push(
           fieldWalker(