@bedrockio/yada 1.0.0

package/src/object.js

@@ -0,0 +1,102 @@
+import TypeSchema from './TypeSchema';
+import { FieldError, LocalizedError } from './errors';
+import { wrapSchema } from './utils';
+import { isSchema } from './Schema';
+
+const BASE_ASSERTIONS = ['type', 'transform', 'field'];
+
+class ObjectSchema extends TypeSchema {
+  constructor(fields = {}) {
+    super(Object, { message: 'Object failed validation.', fields });
+    this.setup();
+  }
+
+  setup() {
+    this.assert('type', (val) => {
+      if (val === null || typeof val !== 'object') {
+        throw new 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 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 FieldError(message, key, original);
+            } else {
+              throw new FieldError(
+                'Field failed validation.',
+                key,
+                error.original,
+                error.details
+              );
+            }
+          }
+          return {
+            ...obj,
+            ...(val !== undefined && {
+              [key]: val,
+            }),
+          };
+        }
+      });
+    }
+  }
+
+  append(arg) {
+    const 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,
+      }),
+    };
+  }
+}
+
+export default wrapSchema(ObjectSchema);

package/src/password.js

@@ -0,0 +1,61 @@
+import { LocalizedError } from './errors';
+
+const LOWER_REG = /[a-z]/g;
+const UPPER_REG = /[A-Z]/g;
+const NUMBER_REG = /[0-9]/g;
+const SYMBOL_REG = /[!@#$%^&*]/g;
+
+export const PASSWORD_DEFAULTS = {
+  minLength: 12,
+  minLowercase: 0,
+  minUppercase: 0,
+  minNumbers: 0,
+  minSymbols: 0,
+};
+
+export function validateLength(expected) {
+  return (str = '') => {
+    if (str.length < expected) {
+      const s = expected === 1 ? '' : 's';
+      throw new LocalizedError('Must be at least {length} character{s}.', {
+        length: expected,
+        s,
+      });
+    }
+  };
+}
+
+export const validateLowercase = validateRegex(
+  LOWER_REG,
+  'Must contain at least {length} lowercase character{s}.'
+);
+
+export const validateUppercase = validateRegex(
+  UPPER_REG,
+  'Must contain at least {length} uppercase character{s}.'
+);
+
+export const validateNumbers = validateRegex(
+  NUMBER_REG,
+  'Must contain at least {length} number{s}.'
+);
+
+export const validateSymbols = validateRegex(
+  SYMBOL_REG,
+  'Must contain at least {length} symbol{s}.'
+);
+
+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 LocalizedError(message, {
+          length: expected,
+          s,
+        });
+      }
+    };
+  };
+}

package/src/string.js

@@ -0,0 +1,303 @@
+import validator from 'validator';
+import TypeSchema from './TypeSchema';
+import { LocalizedError } from './errors';
+import { wrapSchema } from './utils';
+import {
+  PASSWORD_DEFAULTS,
+  validateLength,
+  validateLowercase,
+  validateUppercase,
+  validateNumbers,
+  validateSymbols,
+} from './password';
+
+const SLUG_REG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
+class StringSchema extends TypeSchema {
+  constructor() {
+    super(String);
+    this.assert('type', (val, options) => {
+      if (typeof val !== 'string' && options.cast) {
+        val = String(val);
+      }
+      if (typeof val !== 'string') {
+        throw new LocalizedError('Must be a string.');
+      }
+      return val;
+    });
+  }
+
+  min(length) {
+    return this.clone({ min: length }).assert('length', (str) => {
+      if (str && str.length < length) {
+        throw new 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 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 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 LocalizedError('Must be in upper case.');
+        }
+        return upper;
+      }
+    });
+  }
+
+  match(reg) {
+    if (!(reg instanceof RegExp)) {
+      throw new LocalizedError('Argument must be a regular expression');
+    }
+    return this.clone().assert('regex', (str) => {
+      if (str && !reg.test(str)) {
+        throw new LocalizedError('Must match pattern {reg}.', {
+          reg,
+        });
+      }
+    });
+  }
+
+  email() {
+    return this.format('email', (str) => {
+      if (!validator.isEmail(str)) {
+        throw new LocalizedError('Must be an email address.');
+      }
+    });
+  }
+
+  hex() {
+    return this.format('hex', (str) => {
+      if (!validator.isHexadecimal(str)) {
+        throw new LocalizedError('Must be hexadecimal.');
+      }
+    });
+  }
+
+  md5() {
+    return this.format('md5', (str) => {
+      if (!validator.isHash(str, 'md5')) {
+        throw new LocalizedError('Must be a hash in md5 format.');
+      }
+    });
+  }
+
+  sha1() {
+    return this.format('sha1', (str) => {
+      if (!validator.isHash(str, 'sha1')) {
+        throw new LocalizedError('Must be a hash in sha1 format.');
+      }
+    });
+  }
+
+  ascii() {
+    return this.format('ascii', (str) => {
+      if (!validator.isAscii(str)) {
+        throw new LocalizedError('Must be ASCII.');
+      }
+    });
+  }
+
+  base64(options) {
+    return this.format('base64', (str) => {
+      if (!validator.isBase64(str, options)) {
+        throw new LocalizedError('Must be base64.');
+      }
+    });
+  }
+
+  creditCard() {
+    return this.format('credit-card', (str) => {
+      if (!validator.isCreditCard(str)) {
+        throw new LocalizedError('Must be a valid credit card number.');
+      }
+    });
+  }
+
+  ip() {
+    return this.format('ip', (str) => {
+      if (!validator.isIP(str)) {
+        throw new LocalizedError('Must be a valid IP address.');
+      }
+    });
+  }
+
+  country() {
+    return this.format('country', (str) => {
+      if (!validator.isISO31661Alpha2(str)) {
+        throw new LocalizedError('Must be a valid country code.');
+      }
+    });
+  }
+
+  locale() {
+    return this.format('locale', (str) => {
+      if (!validator.isLocale(str)) {
+        throw new LocalizedError('Must be a valid locale code.');
+      }
+    });
+  }
+
+  jwt() {
+    return this.format('jwt', (str) => {
+      if (!validator.isJWT(str)) {
+        throw new 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 LocalizedError('Must be a valid slug.');
+      }
+    });
+  }
+
+  latlng() {
+    return this.format('latlng', (str) => {
+      if (!validator.isLatLong(str)) {
+        throw new LocalizedError('Must be a valid lat,lng coordinate.');
+      }
+    });
+  }
+
+  postalCode(locale = 'any') {
+    return this.format('postal-code', (str) => {
+      if (!validator.isPostalCode(str, locale)) {
+        throw new LocalizedError('Must be a valid postal code.');
+      }
+    });
+  }
+
+  password(options = {}) {
+    const { minLength, minLowercase, minUppercase, minNumbers, minSymbols } = {
+      ...PASSWORD_DEFAULTS,
+      ...options,
+    };
+
+    const schema = this.clone();
+
+    if (minLength) {
+      schema.assert('password', validateLength(minLength));
+    }
+    if (minLowercase) {
+      schema.assert('password', validateLowercase(minLowercase));
+    }
+    if (minUppercase) {
+      schema.assert('password', validateUppercase(minUppercase));
+    }
+    if (minNumbers) {
+      schema.assert('password', validateNumbers(minNumbers));
+    }
+    if (minSymbols) {
+      schema.assert('password', validateSymbols(minSymbols));
+    }
+
+    return schema;
+  }
+
+  url(options) {
+    return this.format('url', (str) => {
+      if (!validator.isURL(str, options)) {
+        throw new LocalizedError('Must be a valid URL.');
+      }
+    });
+  }
+
+  domain(options) {
+    return this.format('domain', (str) => {
+      if (!validator.isFQDN(str, options)) {
+        throw new LocalizedError('Must be a valid domain.');
+      }
+    });
+  }
+
+  uuid(version) {
+    return this.format('uuid', (str) => {
+      if (!validator.isUUID(str, version)) {
+        throw new LocalizedError('Must be a valid unique id.');
+      }
+    });
+  }
+
+  btc() {
+    return this.format('bitcoin-address', (str) => {
+      if (!validator.isBtcAddress(str)) {
+        throw new LocalizedError('Must be a valid Bitcoin address.');
+      }
+    });
+  }
+
+  eth() {
+    return this.format('etherium-address', (str) => {
+      if (!validator.isEthereumAddress(str)) {
+        throw new LocalizedError('Must be a valid Ethereum address.');
+      }
+    });
+  }
+
+  swift() {
+    return this.format('swift-code', (str) => {
+      if (!validator.isBIC(str)) {
+        throw new LocalizedError('Must be a valid SWIFT code.');
+      }
+    });
+  }
+
+  mongo() {
+    return this.format('mongo-object-id', (str) => {
+      if (!validator.isMongoId(str)) {
+        throw new 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,
+      }),
+    };
+  }
+}
+
+export default wrapSchema(StringSchema);

package/src/utils.js

@@ -0,0 +1,22 @@
+import Schema from './Schema';
+
+export function wrapSchema(Class) {
+  return (...args) => {
+    return new Class(...args);
+  };
+}
+
+export function wrapArgs(name) {
+  return (...args) => {
+    return new Schema()[name](...args);
+  };
+}
+
+export function wrapAny() {
+  return () => {
+    return new Schema();
+  };
+}
+
+export { isSchema } from './Schema';
+export { isSchemaError } from './errors';