@bedrockio/yada 1.0.0

package/src/array.js

@@ -0,0 +1,131 @@
+import Schema from './Schema';
+import { ArrayError, ElementError, LocalizedError } from './errors';
+import { wrapSchema } from './utils';
+
+class ArraySchema extends Schema {
+  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().allow(schemas) : schemas[0];
+
+    this.assert('type', (val, options) => {
+      if (typeof val === 'string' && options.cast) {
+        val = val.split(',');
+      }
+      if (!Array.isArray(val)) {
+        throw new 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 ElementError(error.details[0].message, i));
+            } else {
+              errors.push(
+                new ElementError('Element failed validation.', i, error.details)
+              );
+            }
+          }
+        }
+        if (errors.length) {
+          throw new 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 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 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 LocalizedError('Must be an array of length 2.');
+      } else {
+        const [lat, lng] = arr;
+        if (typeof lat !== 'number' || lat < -90 || lat > 90) {
+          throw new LocalizedError('Invalid latitude.');
+        } else if (typeof lng !== 'number' || lng < -180 || lng > 180) {
+          throw new 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,
+    };
+  }
+}
+
+export default wrapSchema(ArraySchema);

package/src/boolean.js

@@ -0,0 +1,25 @@
+import TypeSchema from './TypeSchema';
+import { LocalizedError } from './errors';
+import { wrapSchema } from './utils';
+
+class BooleanSchema extends TypeSchema {
+  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 LocalizedError('Must be a boolean.');
+      }
+      return val;
+    });
+  }
+}
+
+export default wrapSchema(BooleanSchema);

package/src/date.js

@@ -0,0 +1,130 @@
+import validator from 'validator';
+import { wrapSchema } from './utils';
+import { LocalizedError } from './errors';
+
+import Schema from './Schema';
+
+class DateSchema extends Schema {
+  constructor() {
+    super();
+    this.assert('type', (val) => {
+      const date = new Date(val);
+      if ((!val && val !== 0) || isNaN(date.getTime())) {
+        throw new 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 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 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 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 LocalizedError('Must be after {date}.', {
+          date: min.toISOString(),
+        });
+      }
+    });
+  }
+
+  past() {
+    return this.clone().assert('past', (date) => {
+      const now = new Date();
+      if (date > now) {
+        throw new LocalizedError('Must be in the past.');
+      }
+    });
+  }
+
+  future() {
+    return this.clone().assert('future', (date) => {
+      const now = new Date();
+      if (date < now) {
+        throw new 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 LocalizedError('Must be a string.');
+      } else if (!validator.isISO8601(original)) {
+        throw new LocalizedError('Must be in ISO 8601 format.');
+      }
+    });
+  }
+
+  timestamp() {
+    return this.clone({ format: 'timestamp' }).assert(
+      'format',
+      (date, { original }) => {
+        if (typeof original !== 'number') {
+          throw new LocalizedError('Must be a timestamp in milliseconds.');
+        }
+      }
+    );
+  }
+
+  unix() {
+    return this.clone({ format: 'unix timestamp' }).assert(
+      'format',
+      (date, { original }) => {
+        if (typeof original !== 'number') {
+          throw new 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),
+    };
+  }
+}
+
+export default wrapSchema(DateSchema);

package/src/errors.js

@@ -0,0 +1,92 @@
+import { getFullMessage } from './messages';
+import { localize } from './localization';
+
+export class LocalizedError extends Error {
+  constructor(message, values) {
+    super(localize(message, values));
+  }
+}
+
+export class ValidationError extends Error {
+  constructor(message, details = [], type = 'validation') {
+    super(localize(message));
+    this.details = details;
+    this.type = type;
+  }
+
+  toJSON() {
+    return {
+      type: this.type,
+      message: this.message,
+      details: this.details,
+    };
+  }
+
+  getFullMessage(options) {
+    return getFullMessage(this, {
+      delimiter: ' ',
+      ...options,
+    });
+  }
+}
+
+export 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(),
+    };
+  }
+}
+
+export 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(),
+    };
+  }
+}
+
+export class AssertionError extends Error {
+  constructor(message, type, original) {
+    super(message);
+    this.type = type;
+    this.original = original;
+  }
+
+  toJSON() {
+    return {
+      type: this.type,
+      message: this.message,
+    };
+  }
+}
+
+export class ArrayError extends Error {
+  constructor(message, details) {
+    super(message);
+    this.details = details;
+  }
+}
+
+export function isSchemaError(arg) {
+  return (
+    arg instanceof ValidationError ||
+    arg instanceof AssertionError ||
+    arg instanceof ArrayError
+  );
+}

package/src/index.js

@@ -0,0 +1,51 @@
+import array from './array';
+import boolean from './boolean';
+import date from './date';
+import number from './number';
+import object from './object';
+import string from './string';
+
+import { wrapArgs, wrapAny, isSchema, isSchemaError } from './utils';
+import { useLocalizer, getLocalizerTemplates } from './localization';
+import { LocalizedError } from './errors';
+
+const allow = wrapArgs('allow');
+const reject = wrapArgs('reject');
+const custom = wrapArgs('custom');
+const any = wrapAny();
+
+export default {
+  array,
+  boolean,
+  date,
+  number,
+  object,
+  string,
+  any,
+  allow,
+  reject,
+  custom,
+  isSchema,
+  isSchemaError,
+  useLocalizer,
+  getLocalizerTemplates,
+  LocalizedError,
+};
+
+export {
+  array,
+  boolean,
+  date,
+  number,
+  object,
+  string,
+  any,
+  allow,
+  reject,
+  custom,
+  isSchema,
+  isSchemaError,
+  useLocalizer,
+  getLocalizerTemplates,
+  LocalizedError,
+};

package/src/localization.js

@@ -0,0 +1,38 @@
+const TOKEN_REG = /{(.+?)}/g;
+
+let localizer;
+let templates = {};
+
+export function useLocalizer(arg) {
+  const fn = typeof arg === 'function' ? arg : (template) => arg[template];
+  localizer = fn;
+  templates = {};
+}
+
+export function getLocalized(template) {
+  if (localizer) {
+    return localizer(template);
+  }
+}
+
+export 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];
+  });
+}
+
+export function getLocalizerTemplates() {
+  return templates;
+}

package/src/messages.js

@@ -0,0 +1,72 @@
+import { isSchemaError } from './errors';
+import { localize } from './localization';
+
+export function getFullMessage(error, options) {
+  const { delimiter } = options;
+  if (error.details) {
+    return error.details
+      .map((error) => {
+        if (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 localize(msg, {
+      field: getFieldLabel(field, options),
+    });
+  } else if (index != null) {
+    const msg = `Element at index "{index}" ${base}`;
+    return localize(msg, {
+      index,
+    });
+  } else {
+    return 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/src/number.js

@@ -0,0 +1,84 @@
+import TypeSchema from './TypeSchema';
+import { LocalizedError } from './errors';
+import { wrapSchema } from './utils';
+
+class NumberSchema extends TypeSchema {
+  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 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 LocalizedError(msg, {
+          min,
+        });
+      }
+    });
+  }
+
+  max(max, msg) {
+    msg ||= 'Must be less than {max}.';
+    return this.clone({ max }).assert('max', (num) => {
+      if (num > max) {
+        throw new 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 LocalizedError('Must be an integer.');
+      }
+    });
+  }
+
+  multiple(multiple) {
+    return this.clone({ multiple }).assert('multiple', (num) => {
+      if (num % multiple !== 0) {
+        throw new 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,
+      }),
+    };
+  }
+}
+
+export default wrapSchema(NumberSchema);