@bedrockio/yada 1.0.0 → 1.0.2

package/dist/cjs/Schema.js

@@ -0,0 +1,265 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+exports.isSchema = isSchema;
+var _errors = require("./errors");
+const INITIAL_TYPES = ['default', 'required', 'type', 'transform'];
+const REQUIRED_TYPES = ['default', 'required'];
+class Schema {
+  constructor(meta = {}) {
+    this.assertions = [];
+    this.meta = meta;
+  }
+
+  // Public
+
+  required() {
+    return this.clone({
+      required: true
+    }).assert('required', val => {
+      if (val === undefined) {
+        throw new _errors.LocalizedError('Value is required.');
+      }
+    });
+  }
+  default(value) {
+    return this.clone({
+      default: value
+    }).assert('default', val => {
+      if (val === undefined) {
+        return value;
+      }
+    });
+  }
+  custom(...args) {
+    const type = args.length > 1 ? args[0] : 'custom';
+    const fn = args.length > 1 ? args[1] : args[0];
+    if (!type) {
+      throw new Error('Assertion type required.');
+    } else if (!fn) {
+      throw new Error('Assertion function required.');
+    }
+    return this.clone().assert(type, async (val, options) => {
+      return await fn(val, options);
+    });
+  }
+  allow(...set) {
+    return this.assertEnum(set, true);
+  }
+  reject(...set) {
+    return this.assertEnum(set, false);
+  }
+  message(message) {
+    return this.clone({
+      message
+    });
+  }
+  tag(tags) {
+    return this.clone({
+      tags: {
+        ...this.meta.tags,
+        ...tags
+      }
+    });
+  }
+  description(description) {
+    return this.tag({
+      description
+    });
+  }
+  options(options) {
+    return this.clone({
+      ...options
+    });
+  }
+  async validate(value, options = {}) {
+    let details = [];
+    options = {
+      root: value,
+      ...options,
+      ...this.meta,
+      original: value
+    };
+    for (let assertion of this.assertions) {
+      if (!assertion.required && value === undefined) {
+        break;
+      }
+      try {
+        const result = await this.runAssertion(assertion, value, options);
+        if (result !== undefined) {
+          value = result;
+        }
+      } catch (error) {
+        if (error instanceof _errors.ArrayError) {
+          details = [...details, ...error.details];
+        } else {
+          details.push(error);
+        }
+        if (assertion.halt) {
+          break;
+        }
+      }
+    }
+    if (details.length) {
+      const {
+        message = 'Input failed validation.'
+      } = this.meta;
+      throw new _errors.ValidationError(message, details);
+    }
+    return value;
+  }
+  clone(meta) {
+    const clone = Object.create(this.constructor.prototype);
+    clone.assertions = [...this.assertions];
+    clone.meta = {
+      ...this.meta,
+      ...meta
+    };
+    return clone;
+  }
+
+  // Private
+
+  assertEnum(set, allow) {
+    if (set.length === 1 && Array.isArray(set[0])) {
+      set = set[0];
+    }
+    const types = set.map(el => {
+      if (!isSchema(el)) {
+        el = JSON.stringify(el);
+      }
+      return el;
+    });
+    const msg = `${allow ? 'Must' : 'Must not'} be one of [{types}].`;
+    return this.clone({
+      enum: set
+    }).assert('enum', async (val, options) => {
+      if (val !== undefined) {
+        for (let el of set) {
+          if (isSchema(el)) {
+            try {
+              await el.validate(val, options);
+              return;
+            } catch (error) {
+              continue;
+            }
+          } else if (el === val === allow) {
+            return;
+          }
+        }
+        throw new _errors.LocalizedError(msg, {
+          types: types.join(', ')
+        });
+      }
+    });
+  }
+  assert(type, fn) {
+    this.pushAssertion({
+      halt: INITIAL_TYPES.includes(type),
+      required: REQUIRED_TYPES.includes(type),
+      type,
+      fn
+    });
+    return this;
+  }
+  pushAssertion(assertion) {
+    this.assertions.push(assertion);
+    this.assertions.sort((a, b) => {
+      return this.getSortIndex(a.type) - this.getSortIndex(b.type);
+    });
+  }
+  transform(fn) {
+    this.assert('transform', (val, options) => {
+      if (val !== undefined) {
+        return fn(val, options);
+      }
+    });
+    return this;
+  }
+  getSortIndex(type) {
+    const index = INITIAL_TYPES.indexOf(type);
+    return index === -1 ? INITIAL_TYPES.length : index;
+  }
+  async runAssertion(assertion, value, options = {}) {
+    const {
+      type,
+      fn
+    } = assertion;
+    try {
+      return await fn(value, options);
+    } catch (error) {
+      if ((0, _errors.isSchemaError)(error)) {
+        throw error;
+      }
+      throw new _errors.AssertionError(error.message, type, error);
+    }
+  }
+  toOpenApi(extra) {
+    const {
+      required,
+      format,
+      tags,
+      default: defaultValue
+    } = this.meta;
+    return {
+      ...(required && {
+        required: true
+      }),
+      ...(defaultValue && {
+        default: defaultValue
+      }),
+      ...(format && {
+        format
+      }),
+      ...this.enumToOpenApi(),
+      ...tags,
+      ...extra
+    };
+  }
+  enumToOpenApi() {
+    const {
+      enum: allowed
+    } = this.meta;
+    if (allowed?.length) {
+      const type = typeof allowed[0];
+      const allowEnum = allowed.every(entry => {
+        const entryType = typeof entry;
+        return entryType !== 'object' && entryType === type;
+      });
+      if (allowEnum) {
+        return {
+          type,
+          enum: allowed
+        };
+      } else {
+        const oneOf = [];
+        for (let entry of allowed) {
+          if (isSchema(entry)) {
+            oneOf.push(entry.toOpenApi());
+          } else {
+            const type = typeof entry;
+            let forType = oneOf.find(el => {
+              return el.type === type;
+            });
+            if (!forType) {
+              forType = {
+                type,
+                enum: []
+              };
+              oneOf.push(forType);
+            }
+            forType.enum.push(entry);
+          }
+        }
+        return {
+          oneOf
+        };
+      }
+    }
+  }
+}
+exports.default = Schema;
+function isSchema(arg) {
+  return arg instanceof Schema;
+}

package/dist/cjs/TypeSchema.js

@@ -0,0 +1,30 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _Schema = _interopRequireDefault(require("./Schema"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class TypeSchema extends _Schema.default {
+  constructor(Class, meta) {
+    const type = Class.name.toLowerCase();
+    super({
+      type,
+      ...meta
+    });
+  }
+  format(name, fn) {
+    return this.clone({
+      format: name
+    }).assert('format', fn);
+  }
+  toString() {
+    return this.meta.type;
+  }
+  toOpenApi(extra) {
+    return {
+      type: this.meta.type,
+      ...super.toOpenApi(extra)
+    };
+  }
+}
+exports.default = TypeSchema;

package/dist/cjs/array.js

@@ -0,0 +1,128 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _Schema = _interopRequireDefault(require("./Schema"));
+var _errors = require("./errors");
+var _utils = require("./utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class ArraySchema extends _Schema.default {
+  constructor(...args) {
+    let schemas, meta;
+    if (Array.isArray(args[0])) {
+      schemas = args[0];
+      meta = args[1];
+    } else {
+      schemas = args;
+    }
+    super({
+      message: 'Array failed validation.',
+      ...meta,
+      schemas
+    });
+    this.setup();
+  }
+  setup() {
+    const {
+      schemas
+    } = this.meta;
+    const schema = schemas.length > 1 ? new _Schema.default().allow(schemas) : schemas[0];
+    this.assert('type', (val, options) => {
+      if (typeof val === 'string' && options.cast) {
+        val = val.split(',');
+      }
+      if (!Array.isArray(val)) {
+        throw new _errors.LocalizedError('Must be an array.');
+      }
+      return val;
+    });
+    if (schema) {
+      this.assert('elements', async (arr, options) => {
+        const errors = [];
+        const result = [];
+        for (let i = 0; i < arr.length; i++) {
+          const el = arr[i];
+          try {
+            result.push(await schema.validate(el, options));
+          } catch (error) {
+            if (error.details?.length === 1) {
+              errors.push(new _errors.ElementError(error.details[0].message, i));
+            } else {
+              errors.push(new _errors.ElementError('Element failed validation.', i, error.details));
+            }
+          }
+        }
+        if (errors.length) {
+          throw new _errors.ArrayError(this.meta.message, errors);
+        } else {
+          return result;
+        }
+      });
+    }
+  }
+  min(length) {
+    return this.clone().assert('length', arr => {
+      if (arr.length < length) {
+        const s = length === 1 ? '' : 's';
+        throw new _errors.LocalizedError('Must contain at least {length} element{s}.', {
+          length,
+          s
+        });
+      }
+    });
+  }
+  max(length) {
+    return this.clone().assert('length', arr => {
+      if (arr.length > length) {
+        const s = length === 1 ? '' : 's';
+        throw new _errors.LocalizedError('Cannot contain more than {length} element{s}.', {
+          length,
+          s
+        });
+      }
+    });
+  }
+  latlng() {
+    return this.clone({
+      format: 'latlng'
+    }).assert('format', arr => {
+      if (arr.length !== 2) {
+        throw new _errors.LocalizedError('Must be an array of length 2.');
+      } else {
+        const [lat, lng] = arr;
+        if (typeof lat !== 'number' || lat < -90 || lat > 90) {
+          throw new _errors.LocalizedError('Invalid latitude.');
+        } else if (typeof lng !== 'number' || lng < -180 || lng > 180) {
+          throw new _errors.LocalizedError('Invalid longitude.');
+        }
+      }
+    });
+  }
+  toString() {
+    return 'array';
+  }
+  toOpenApi(extra) {
+    let other;
+    const {
+      schemas
+    } = this.meta;
+    if (schemas.length > 1) {
+      other = {
+        oneOf: schemas.map(schema => {
+          return schema.toOpenApi();
+        })
+      };
+    } else if (schemas.length === 1) {
+      other = {
+        items: schemas[0].toOpenApi()
+      };
+    }
+    return {
+      type: 'array',
+      ...super.toOpenApi(extra),
+      ...other
+    };
+  }
+}
+var _default = (0, _utils.wrapSchema)(ArraySchema);
+exports.default = _default;

package/dist/cjs/boolean.js

@@ -0,0 +1,29 @@
+"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 BooleanSchema extends _TypeSchema.default {
+  constructor() {
+    super(Boolean);
+    this.assert('type', (val, options) => {
+      if (typeof val === 'string' && options.cast) {
+        const str = val.toLowerCase();
+        if (str === 'true' || str === '1') {
+          val = true;
+        } else if (str === 'false' || str === '0') {
+          val = false;
+        }
+      }
+      if (typeof val !== 'boolean') {
+        throw new _errors.LocalizedError('Must be a boolean.');
+      }
+      return val;
+    });
+  }
+}
+var _default = (0, _utils.wrapSchema)(BooleanSchema);
+exports.default = _default;

package/dist/cjs/date.js

@@ -0,0 +1,130 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+var _validator = _interopRequireDefault(require("validator"));
+var _utils = require("./utils");
+var _errors = require("./errors");
+var _Schema = _interopRequireDefault(require("./Schema"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class DateSchema extends _Schema.default {
+  constructor() {
+    super();
+    this.assert('type', val => {
+      const date = new Date(val);
+      if (!val && val !== 0 || isNaN(date.getTime())) {
+        throw new _errors.LocalizedError('Must be a valid date input.');
+      } else {
+        return date;
+      }
+    });
+  }
+  min(min) {
+    min = new Date(min);
+    return this.clone().assert('min', date => {
+      if (date < min) {
+        throw new _errors.LocalizedError('Must be after {date}.', {
+          date: min.toISOString()
+        });
+      }
+    });
+  }
+  max(max) {
+    max = new Date(max);
+    return this.clone().assert('max', date => {
+      if (date > max) {
+        throw new _errors.LocalizedError('Must be before {date}.', {
+          date: max.toISOString()
+        });
+      }
+    });
+  }
+  before(max) {
+    max = new Date(max);
+    return this.clone().assert('before', date => {
+      if (date >= max) {
+        throw new _errors.LocalizedError('Must be before {date}.', {
+          date: max.toISOString()
+        });
+      }
+    });
+  }
+  after(min) {
+    min = new Date(min);
+    return this.clone().assert('after', date => {
+      if (date <= min) {
+        throw new _errors.LocalizedError('Must be after {date}.', {
+          date: min.toISOString()
+        });
+      }
+    });
+  }
+  past() {
+    return this.clone().assert('past', date => {
+      const now = new Date();
+      if (date > now) {
+        throw new _errors.LocalizedError('Must be in the past.');
+      }
+    });
+  }
+  future() {
+    return this.clone().assert('future', date => {
+      const now = new Date();
+      if (date < now) {
+        throw new _errors.LocalizedError('Must be in the future.');
+      }
+    });
+  }
+  iso(format = 'date-time') {
+    return this.clone({
+      format
+    }).assert('format', (val, options) => {
+      const {
+        original
+      } = options;
+      if (typeof original !== 'string') {
+        throw new _errors.LocalizedError('Must be a string.');
+      } else if (!_validator.default.isISO8601(original)) {
+        throw new _errors.LocalizedError('Must be in ISO 8601 format.');
+      }
+    });
+  }
+  timestamp() {
+    return this.clone({
+      format: 'timestamp'
+    }).assert('format', (date, {
+      original
+    }) => {
+      if (typeof original !== 'number') {
+        throw new _errors.LocalizedError('Must be a timestamp in milliseconds.');
+      }
+    });
+  }
+  unix() {
+    return this.clone({
+      format: 'unix timestamp'
+    }).assert('format', (date, {
+      original
+    }) => {
+      if (typeof original !== 'number') {
+        throw new _errors.LocalizedError('Must be a timestamp in seconds.');
+      } else {
+        return new Date(original * 1000);
+      }
+    });
+  }
+  toString() {
+    return 'date';
+  }
+  toOpenApi(extra) {
+    const {
+      format
+    } = this.meta;
+    return {
+      type: format.includes('timestamp') ? 'number' : 'string',
+      ...super.toOpenApi(extra)
+    };
+  }
+}
+var _default = (0, _utils.wrapSchema)(DateSchema);
+exports.default = _default;

package/dist/cjs/errors.js

@@ -0,0 +1,87 @@
+"use strict";
+
+exports.__esModule = true;
+exports.ValidationError = exports.LocalizedError = exports.FieldError = exports.ElementError = exports.AssertionError = exports.ArrayError = void 0;
+exports.isSchemaError = isSchemaError;
+var _messages = require("./messages");
+var _localization = require("./localization");
+class LocalizedError extends Error {
+  constructor(message, values) {
+    super((0, _localization.localize)(message, values));
+  }
+}
+exports.LocalizedError = LocalizedError;
+class ValidationError extends Error {
+  constructor(message, details = [], type = 'validation') {
+    super((0, _localization.localize)(message));
+    this.details = details;
+    this.type = type;
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      message: this.message,
+      details: this.details
+    };
+  }
+  getFullMessage(options) {
+    return (0, _messages.getFullMessage)(this, {
+      delimiter: ' ',
+      ...options
+    });
+  }
+}
+exports.ValidationError = ValidationError;
+class FieldError extends ValidationError {
+  constructor(message, field, original, details) {
+    super(message, details, 'field');
+    this.field = field;
+    this.original = original;
+    this.details = details;
+  }
+  toJSON() {
+    return {
+      field: this.field,
+      ...super.toJSON()
+    };
+  }
+}
+exports.FieldError = FieldError;
+class ElementError extends ValidationError {
+  constructor(message, index, details) {
+    super(message, details, 'element');
+    this.index = index;
+    this.details = details;
+  }
+  toJSON() {
+    return {
+      index: this.index,
+      ...super.toJSON()
+    };
+  }
+}
+exports.ElementError = ElementError;
+class AssertionError extends Error {
+  constructor(message, type, original) {
+    super(message);
+    this.type = type;
+    this.original = original;
+  }
+  toJSON() {
+    return {
+      type: this.type,
+      message: this.message
+    };
+  }
+}
+exports.AssertionError = AssertionError;
+class ArrayError extends Error {
+  constructor(message, details) {
+    super(message);
+    this.details = details;
+  }
+}
+exports.ArrayError = ArrayError;
+function isSchemaError(arg) {
+  return arg instanceof ValidationError || arg instanceof AssertionError || arg instanceof ArrayError;
+}