@bedrockio/yada 1.0.1 → 1.0.3

package/dist/cjs/localization.js

@@ -0,0 +1,39 @@
+"use strict";
+
+exports.__esModule = true;
+exports.getLocalized = getLocalized;
+exports.getLocalizerTemplates = getLocalizerTemplates;
+exports.localize = localize;
+exports.useLocalizer = useLocalizer;
+const TOKEN_REG = /{(.+?)}/g;
+let localizer;
+let templates = {};
+function useLocalizer(arg) {
+  const fn = typeof arg === 'function' ? arg : template => arg[template];
+  localizer = fn;
+  templates = {};
+}
+function getLocalized(template) {
+  if (localizer) {
+    return localizer(template);
+  }
+}
+function localize(template, values = {}) {
+  let message = template;
+  if (localizer) {
+    let localized = getLocalized(template);
+    if (typeof localized === 'function') {
+      localized = localized(values);
+    }
+    if (localized) {
+      message = localized;
+    }
+  }
+  templates[template] = message;
+  return message.replace(TOKEN_REG, (match, token) => {
+    return values[token];
+  });
+}
+function getLocalizerTemplates() {
+  return templates;
+}

package/dist/cjs/messages.js

@@ -0,0 +1,75 @@
+"use strict";
+
+exports.__esModule = true;
+exports.getFullMessage = getFullMessage;
+var _errors = require("./errors");
+var _localization = require("./localization");
+function getFullMessage(error, options) {
+  const {
+    delimiter
+  } = options;
+  if (error.details) {
+    return error.details.map(error => {
+      if ((0, _errors.isSchemaError)(error)) {
+        return getFullMessage(error, {
+          field: error.field,
+          index: error.index,
+          ...options
+        });
+      } else {
+        return error.message;
+      }
+    }).join(delimiter);
+  } else {
+    return getLabeledMessage(error, options);
+  }
+}
+function getLabeledMessage(error, options) {
+  const {
+    field,
+    index
+  } = options;
+  const base = getBase(error.message);
+  if (field) {
+    const msg = `{field} ${base}`;
+    return (0, _localization.localize)(msg, {
+      field: getFieldLabel(field, options)
+    });
+  } else if (index != null) {
+    const msg = `Element at index "{index}" ${base}`;
+    return (0, _localization.localize)(msg, {
+      index
+    });
+  } else {
+    return (0, _localization.localize)(base);
+  }
+}
+function getFieldLabel(field, options) {
+  const {
+    natural
+  } = options;
+  if (natural) {
+    return naturalize(field);
+  } else {
+    return `"${field}"`;
+  }
+}
+function getBase(str) {
+  if (str === 'Value is required.') {
+    return 'is required.';
+  } else {
+    return downcase(str);
+  }
+}
+function naturalize(str) {
+  const first = str.slice(0, 1).toUpperCase();
+  let rest = str.slice(1);
+  rest = rest.replace(/[A-Z]+/, caps => {
+    return ' ' + caps.toLowerCase();
+  });
+  rest = rest.replace(/[-_]/g, ' ');
+  return first + rest;
+}
+function downcase(str) {
+  return str.slice(0, 1).toLowerCase() + str.slice(1);
+}

package/dist/cjs/number.js

@@ -0,0 +1,91 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _TypeSchema = _interopRequireDefault(require("./TypeSchema"));
+var _errors = require("./errors");
+var _utils = require("./utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class NumberSchema extends _TypeSchema.default {
+  constructor() {
+    super(Number);
+    this.assert('type', (val, options) => {
+      if (typeof val === 'string' && options.cast) {
+        val = Number(val);
+      }
+      if (typeof val !== 'number' || isNaN(val)) {
+        throw new _errors.LocalizedError('Must be a number.');
+      }
+      return val;
+    });
+  }
+  min(min, msg) {
+    msg ||= 'Must be greater than {min}.';
+    return this.clone({
+      min
+    }).assert('min', num => {
+      if (num < min) {
+        throw new _errors.LocalizedError(msg, {
+          min
+        });
+      }
+    });
+  }
+  max(max, msg) {
+    msg ||= 'Must be less than {max}.';
+    return this.clone({
+      max
+    }).assert('max', num => {
+      if (num > max) {
+        throw new _errors.LocalizedError(msg, {
+          max
+        });
+      }
+    });
+  }
+  negative() {
+    return this.max(0, 'Must be negative.');
+  }
+  positive() {
+    return this.min(0, 'Must be positive.');
+  }
+  integer() {
+    return this.clone().assert('integer', num => {
+      if (!Number.isInteger(num)) {
+        throw new _errors.LocalizedError('Must be an integer.');
+      }
+    });
+  }
+  multiple(multiple) {
+    return this.clone({
+      multiple
+    }).assert('multiple', num => {
+      if (num % multiple !== 0) {
+        throw new _errors.LocalizedError('Must be a multiple of {multiple}.', {
+          multiple
+        });
+      }
+    });
+  }
+  toOpenApi(extra) {
+    const {
+      min,
+      max,
+      multiple
+    } = this.meta;
+    return {
+      ...super.toOpenApi(extra),
+      ...(min != null && {
+        minimum: min
+      }),
+      ...(max != null && {
+        maximum: max
+      }),
+      ...(multiple != null && {
+        multipleOf: multiple
+      })
+    };
+  }
+}
+var _default = (0, _utils.wrapSchema)(NumberSchema);
+exports.default = _default;

package/dist/cjs/object.js

@@ -0,0 +1,104 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _TypeSchema = _interopRequireDefault(require("./TypeSchema"));
+var _errors = require("./errors");
+var _utils = require("./utils");
+var _Schema = require("./Schema");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const BASE_ASSERTIONS = ['type', 'transform', 'field'];
+class ObjectSchema extends _TypeSchema.default {
+  constructor(fields = {}) {
+    super(Object, {
+      message: 'Object failed validation.',
+      fields
+    });
+    this.setup();
+  }
+  setup() {
+    this.assert('type', val => {
+      if (val === null || typeof val !== 'object') {
+        throw new _errors.LocalizedError('Must be an object.');
+      }
+    });
+    this.transform((obj, options) => {
+      const {
+        fields,
+        stripUnknown
+      } = options;
+      const allowUnknown = Object.keys(fields).length === 0;
+      if (obj) {
+        const result = {};
+        for (let key of Object.keys(obj)) {
+          if (key in fields || allowUnknown) {
+            result[key] = obj[key];
+          } else if (!stripUnknown) {
+            throw new _errors.LocalizedError('Unknown field "{key}".', {
+              key
+            });
+          }
+        }
+        return result;
+      }
+    });
+    for (let [key, schema] of Object.entries(this.meta.fields)) {
+      this.assert('field', async (obj, options) => {
+        if (obj) {
+          let val;
+          try {
+            val = await schema.validate(obj[key], options);
+          } catch (error) {
+            if (error.details?.length === 1) {
+              const {
+                message,
+                original
+              } = error.details[0];
+              throw new _errors.FieldError(message, key, original);
+            } else {
+              throw new _errors.FieldError('Field failed validation.', key, error.original, error.details);
+            }
+          }
+          return {
+            ...obj,
+            ...(val !== undefined && {
+              [key]: val
+            })
+          };
+        }
+      });
+    }
+  }
+  append(arg) {
+    const schema = (0, _Schema.isSchema)(arg) ? arg : new ObjectSchema(arg);
+    const fields = {
+      ...this.meta.fields,
+      ...schema.meta.fields
+    };
+    const merged = new ObjectSchema(fields);
+    const assertions = [...this.assertions, ...schema.assertions];
+    for (let assertion of assertions) {
+      const {
+        type
+      } = assertion;
+      if (!BASE_ASSERTIONS.includes(type)) {
+        merged.pushAssertion(assertion);
+      }
+    }
+    return merged;
+  }
+  toOpenApi(extra) {
+    const properties = {};
+    for (let [key, schema] of Object.entries(this.meta.fields)) {
+      properties[key] = schema.toOpenApi();
+    }
+    return {
+      ...super.toOpenApi(extra),
+      ...(Object.keys(properties).length > 0 && {
+        properties
+      })
+    };
+  }
+}
+var _default = (0, _utils.wrapSchema)(ObjectSchema);
+exports.default = _default;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{ "type": "commonjs" }

package/dist/cjs/password.js

@@ -0,0 +1,52 @@
+"use strict";
+
+exports.__esModule = true;
+exports.PASSWORD_DEFAULTS = void 0;
+exports.validateLength = validateLength;
+exports.validateUppercase = exports.validateSymbols = exports.validateNumbers = exports.validateLowercase = void 0;
+var _errors = require("./errors");
+const LOWER_REG = /[a-z]/g;
+const UPPER_REG = /[A-Z]/g;
+const NUMBER_REG = /[0-9]/g;
+const SYMBOL_REG = /[!@#$%^&*]/g;
+const PASSWORD_DEFAULTS = {
+  minLength: 12,
+  minLowercase: 0,
+  minUppercase: 0,
+  minNumbers: 0,
+  minSymbols: 0
+};
+exports.PASSWORD_DEFAULTS = PASSWORD_DEFAULTS;
+function validateLength(expected) {
+  return (str = '') => {
+    if (str.length < expected) {
+      const s = expected === 1 ? '' : 's';
+      throw new _errors.LocalizedError('Must be at least {length} character{s}.', {
+        length: expected,
+        s
+      });
+    }
+  };
+}
+const validateLowercase = validateRegex(LOWER_REG, 'Must contain at least {length} lowercase character{s}.');
+exports.validateLowercase = validateLowercase;
+const validateUppercase = validateRegex(UPPER_REG, 'Must contain at least {length} uppercase character{s}.');
+exports.validateUppercase = validateUppercase;
+const validateNumbers = validateRegex(NUMBER_REG, 'Must contain at least {length} number{s}.');
+exports.validateNumbers = validateNumbers;
+const validateSymbols = validateRegex(SYMBOL_REG, 'Must contain at least {length} symbol{s}.');
+exports.validateSymbols = validateSymbols;
+function validateRegex(reg, message) {
+  return expected => {
+    return (str = '') => {
+      const length = str.match(reg)?.length || 0;
+      if (length < expected) {
+        const s = expected === 1 ? '' : 's';
+        throw new _errors.LocalizedError(message, {
+          length: expected,
+          s
+        });
+      }
+    };
+  };
+}

package/dist/cjs/string.js

@@ -0,0 +1,280 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _validator = _interopRequireDefault(require("validator"));
+var _TypeSchema = _interopRequireDefault(require("./TypeSchema"));
+var _errors = require("./errors");
+var _utils = require("./utils");
+var _password = require("./password");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const SLUG_REG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+class StringSchema extends _TypeSchema.default {
+  constructor() {
+    super(String);
+    this.assert('type', (val, options) => {
+      if (typeof val !== 'string' && options.cast) {
+        val = String(val);
+      }
+      if (typeof val !== 'string') {
+        throw new _errors.LocalizedError('Must be a string.');
+      }
+      return val;
+    });
+  }
+  min(length) {
+    return this.clone({
+      min: length
+    }).assert('length', str => {
+      if (str && str.length < length) {
+        throw new _errors.LocalizedError('Must be {length} characters or more.', {
+          length
+        });
+      }
+    });
+  }
+  max(length) {
+    return this.clone({
+      max: length
+    }).assert('length', str => {
+      if (str && str.length > length) {
+        throw new _errors.LocalizedError('Must be {length} characters or less.', {
+          length
+        });
+      }
+    });
+  }
+  trim() {
+    return this.clone().transform(str => {
+      return str.trim();
+    });
+  }
+  lowercase(assert = false) {
+    return this.clone().transform(str => {
+      const lower = str.toLowerCase();
+      if (lower !== str) {
+        if (assert) {
+          throw new _errors.LocalizedError('Must be in lower case.');
+        }
+        return lower;
+      }
+    });
+  }
+  uppercase(assert = false) {
+    return this.clone().transform(str => {
+      const upper = str.toUpperCase();
+      if (upper !== str) {
+        if (assert) {
+          throw new _errors.LocalizedError('Must be in upper case.');
+        }
+        return upper;
+      }
+    });
+  }
+  match(reg) {
+    if (!(reg instanceof RegExp)) {
+      throw new _errors.LocalizedError('Argument must be a regular expression');
+    }
+    return this.clone().assert('regex', str => {
+      if (str && !reg.test(str)) {
+        throw new _errors.LocalizedError('Must match pattern {reg}.', {
+          reg
+        });
+      }
+    });
+  }
+  email() {
+    return this.format('email', str => {
+      if (!_validator.default.isEmail(str)) {
+        throw new _errors.LocalizedError('Must be an email address.');
+      }
+    });
+  }
+  hex() {
+    return this.format('hex', str => {
+      if (!_validator.default.isHexadecimal(str)) {
+        throw new _errors.LocalizedError('Must be hexadecimal.');
+      }
+    });
+  }
+  md5() {
+    return this.format('md5', str => {
+      if (!_validator.default.isHash(str, 'md5')) {
+        throw new _errors.LocalizedError('Must be a hash in md5 format.');
+      }
+    });
+  }
+  sha1() {
+    return this.format('sha1', str => {
+      if (!_validator.default.isHash(str, 'sha1')) {
+        throw new _errors.LocalizedError('Must be a hash in sha1 format.');
+      }
+    });
+  }
+  ascii() {
+    return this.format('ascii', str => {
+      if (!_validator.default.isAscii(str)) {
+        throw new _errors.LocalizedError('Must be ASCII.');
+      }
+    });
+  }
+  base64(options) {
+    return this.format('base64', str => {
+      if (!_validator.default.isBase64(str, options)) {
+        throw new _errors.LocalizedError('Must be base64.');
+      }
+    });
+  }
+  creditCard() {
+    return this.format('credit-card', str => {
+      if (!_validator.default.isCreditCard(str)) {
+        throw new _errors.LocalizedError('Must be a valid credit card number.');
+      }
+    });
+  }
+  ip() {
+    return this.format('ip', str => {
+      if (!_validator.default.isIP(str)) {
+        throw new _errors.LocalizedError('Must be a valid IP address.');
+      }
+    });
+  }
+  country() {
+    return this.format('country', str => {
+      if (!_validator.default.isISO31661Alpha2(str)) {
+        throw new _errors.LocalizedError('Must be a valid country code.');
+      }
+    });
+  }
+  locale() {
+    return this.format('locale', str => {
+      if (!_validator.default.isLocale(str)) {
+        throw new _errors.LocalizedError('Must be a valid locale code.');
+      }
+    });
+  }
+  jwt() {
+    return this.format('jwt', str => {
+      if (!_validator.default.isJWT(str)) {
+        throw new _errors.LocalizedError('Must be a valid JWT token.');
+      }
+    });
+  }
+  slug() {
+    return this.format('slug', str => {
+      // Validator shows some issues here so use a custom regex.
+      if (!SLUG_REG.test(str)) {
+        throw new _errors.LocalizedError('Must be a valid slug.');
+      }
+    });
+  }
+  latlng() {
+    return this.format('latlng', str => {
+      if (!_validator.default.isLatLong(str)) {
+        throw new _errors.LocalizedError('Must be a valid lat,lng coordinate.');
+      }
+    });
+  }
+  postalCode(locale = 'any') {
+    return this.format('postal-code', str => {
+      if (!_validator.default.isPostalCode(str, locale)) {
+        throw new _errors.LocalizedError('Must be a valid postal code.');
+      }
+    });
+  }
+  password(options = {}) {
+    const {
+      minLength,
+      minLowercase,
+      minUppercase,
+      minNumbers,
+      minSymbols
+    } = {
+      ..._password.PASSWORD_DEFAULTS,
+      ...options
+    };
+    const schema = this.clone();
+    if (minLength) {
+      schema.assert('password', (0, _password.validateLength)(minLength));
+    }
+    if (minLowercase) {
+      schema.assert('password', (0, _password.validateLowercase)(minLowercase));
+    }
+    if (minUppercase) {
+      schema.assert('password', (0, _password.validateUppercase)(minUppercase));
+    }
+    if (minNumbers) {
+      schema.assert('password', (0, _password.validateNumbers)(minNumbers));
+    }
+    if (minSymbols) {
+      schema.assert('password', (0, _password.validateSymbols)(minSymbols));
+    }
+    return schema;
+  }
+  url(options) {
+    return this.format('url', str => {
+      if (!_validator.default.isURL(str, options)) {
+        throw new _errors.LocalizedError('Must be a valid URL.');
+      }
+    });
+  }
+  domain(options) {
+    return this.format('domain', str => {
+      if (!_validator.default.isFQDN(str, options)) {
+        throw new _errors.LocalizedError('Must be a valid domain.');
+      }
+    });
+  }
+  uuid(version) {
+    return this.format('uuid', str => {
+      if (!_validator.default.isUUID(str, version)) {
+        throw new _errors.LocalizedError('Must be a valid unique id.');
+      }
+    });
+  }
+  btc() {
+    return this.format('bitcoin-address', str => {
+      if (!_validator.default.isBtcAddress(str)) {
+        throw new _errors.LocalizedError('Must be a valid Bitcoin address.');
+      }
+    });
+  }
+  eth() {
+    return this.format('etherium-address', str => {
+      if (!_validator.default.isEthereumAddress(str)) {
+        throw new _errors.LocalizedError('Must be a valid Ethereum address.');
+      }
+    });
+  }
+  swift() {
+    return this.format('swift-code', str => {
+      if (!_validator.default.isBIC(str)) {
+        throw new _errors.LocalizedError('Must be a valid SWIFT code.');
+      }
+    });
+  }
+  mongo() {
+    return this.format('mongo-object-id', str => {
+      if (!_validator.default.isMongoId(str)) {
+        throw new _errors.LocalizedError('Must be a valid ObjectId.');
+      }
+    });
+  }
+  toOpenApi(extra) {
+    const {
+      min,
+      max
+    } = this.meta;
+    return {
+      ...super.toOpenApi(extra),
+      ...(min != null && {
+        minLength: min
+      }),
+      ...(max != null && {
+        maxLength: max
+      })
+    };
+  }
+}
+var _default = (0, _utils.wrapSchema)(StringSchema);
+exports.default = _default;

package/dist/cjs/utils.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+exports.isSchemaError = exports.isSchema = void 0;
+exports.wrapAny = wrapAny;
+exports.wrapArgs = wrapArgs;
+exports.wrapSchema = wrapSchema;
+var _Schema = _interopRequireWildcard(require("./Schema"));
+exports.isSchema = _Schema.isSchema;
+var _errors = require("./errors");
+exports.isSchemaError = _errors.isSchemaError;
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function wrapSchema(Class) {
+  return (...args) => {
+    return new Class(...args);
+  };
+}
+function wrapArgs(name) {
+  return (...args) => {
+    return new _Schema.default()[name](...args);
+  };
+}
+function wrapAny() {
+  return () => {
+    return new _Schema.default();
+  };
+}

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "@bedrockio/yada",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Validation library inspired by Joi.",
   "scripts": {
     "test": "NODE_OPTIONS=--experimental-vm-modules jest",
+    "lint": "eslint",
     "build": "scripts/build",
-    "lint": "eslint"
+    "prepublish": "scripts/build"
   },
   "type": "module",
+  "main": "dist/cjs/index.js",
+  "module": "src/index.js",
   "repository": "https://github.com/bedrockio/yada",
   "author": "Andrew Plummer <plummer.andrew@gmail.com>",
   "license": "MIT",