@bedrockio/yada 1.0.13 → 1.0.14

package/dist/cjs/utils.js

@@ -15,25 +15,11 @@ Object.defineProperty(exports, "isSchemaError", {
     return _errors.isSchemaError;
   }
 });
-exports.wrapAny = wrapAny;
-exports.wrapArgs = wrapArgs;
 exports.wrapSchema = wrapSchema;
-var _Schema = _interopRequireWildcard(require("./Schema"));
+var _Schema = require("./Schema");
 var _errors = require("./errors");
-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,16 +1,18 @@
 {
   "name": "@bedrockio/yada",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "description": "Validation library inspired by Joi.",
   "scripts": {
     "test": "jest",
     "lint": "eslint",
     "build": "scripts/build",
-    "prepublishOnly": "npm run build"
+    "types": "tsc",
+    "prepublishOnly": "yarn build && yarn types"
   },
   "type": "module",
-  "main": "dist/cjs/index.js",
-  "module": "src/index.js",
+  "main": "./dist/cjs/index.js",
+  "module": "./src/index.js",
+  "types": "./types/index.d.ts",
   "repository": "https://github.com/bedrockio/yada",
   "author": "Andrew Plummer <plummer.andrew@gmail.com>",
   "license": "MIT",
@@ -26,7 +28,8 @@
     "eslint": "^8.26.0",
     "eslint-plugin-bedrock": "^1.0.17",
     "jest": "^29.2.2",
-    "prettier": "^2.7.1"
+    "prettier": "^2.7.1",
+    "typescript": "^4.9.5"
   },
   "exports": {
     ".": {

package/src/Schema.js

@@ -9,6 +9,10 @@ import {
 const INITIAL_TYPES = ['default', 'required', 'type', 'transform'];
 const REQUIRED_TYPES = ['default', 'required'];
 
+/**
+ * @typedef {[fn: Function] | [type: string, fn: Function]} CustomSignature
+ */
+
 export default class Schema {
   constructor(meta = {}) {
     this.assertions = [];
@@ -33,9 +37,18 @@ export default class Schema {
     });
   }
 
+  /**
+   * @param {CustomSignature} args
+   */
   custom(...args) {
-    const type = args.length > 1 ? args[0] : 'custom';
-    const fn = args.length > 1 ? args[1] : args[0];
+    let type, fn;
+    if (typeof args[0] === 'function') {
+      type = 'custom';
+      fn = args[0];
+    } else {
+      type = args[0];
+      fn = args[1];
+    }
     if (!type) {
       throw new Error('Assertion type required.');
     } else if (!fn) {
@@ -120,6 +133,9 @@ export default class Schema {
     return value;
   }
 
+  /**
+   * @returns {this}
+   */
   clone(meta) {
     const clone = Object.create(this.constructor.prototype);
     clone.assertions = [...this.assertions];
@@ -127,12 +143,33 @@ export default class Schema {
     return clone;
   }
 
+  /**
+   * @returns {Schema}
+   */
   append(schema) {
     const merged = this.clone(schema.meta);
     merged.assertions = [...this.assertions, ...schema.assertions];
     return merged;
   }
 
+  toOpenApi(extra) {
+    const { required, format, tags, default: defaultValue } = this.meta;
+    return {
+      ...(required && {
+        required: true,
+      }),
+      ...(defaultValue && {
+        default: defaultValue,
+      }),
+      ...(format && {
+        format,
+      }),
+      ...this.enumToOpenApi(),
+      ...tags,
+      ...extra,
+    };
+  }
+
   // Private
 
   assertEnum(set, allow) {
@@ -210,24 +247,6 @@ export default class Schema {
     }
   }
 
-  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) {

package/src/array.js

@@ -17,6 +17,9 @@ class ArraySchema extends Schema {
     this.setup();
   }
 
+  /**
+   * @private
+   */
   setup() {
     const { schemas } = this.meta;
     const schema =
@@ -140,4 +143,10 @@ class ArraySchema extends Schema {
   }
 }
 
+/**
+ * @type {{
+ *   (...schemas: Schema[]) : ArraySchema;
+ *   (schemas: Schema[]) : ArraySchema;
+ * }}
+ */
 export default wrapSchema(ArraySchema);

package/src/boolean.js

@@ -22,4 +22,7 @@ class BooleanSchema extends TypeSchema {
   }
 }
 
+/**
+ * @type {function(): BooleanSchema}
+ */
 export default wrapSchema(BooleanSchema);

package/src/date.js

@@ -17,44 +17,60 @@ class DateSchema extends Schema {
     });
   }
 
+  /**
+   * @param {string|number|Date} min
+   */
   min(min) {
     min = new Date(min);
     return this.clone().assert('min', (date) => {
       if (date < min) {
         throw new LocalizedError('Must be after {date}.', {
+          // @ts-ignore
           date: min.toISOString(),
         });
       }
     });
   }
 
+  /**
+   * @param {string|number|Date} max
+   */
   max(max) {
     max = new Date(max);
     return this.clone().assert('max', (date) => {
       if (date > max) {
         throw new LocalizedError('Must be before {date}.', {
+          // @ts-ignore
           date: max.toISOString(),
         });
       }
     });
   }
 
+  /**
+   * @param {string|number|Date} max
+   */
   before(max) {
     max = new Date(max);
     return this.clone().assert('before', (date) => {
       if (date >= max) {
         throw new LocalizedError('Must be before {date}.', {
+          // @ts-ignore
           date: max.toISOString(),
         });
       }
     });
   }
 
+  /**
+   * @param {string|number|Date} min
+   */
   after(min) {
     min = new Date(min);
     return this.clone().assert('after', (date) => {
       if (date <= min) {
         throw new LocalizedError('Must be after {date}.', {
+          // @ts-ignore
           date: min.toISOString(),
         });
       }
@@ -79,6 +95,9 @@ class DateSchema extends Schema {
     });
   }
 
+  /**
+   * @param {"date" | "date-time"} format
+   */
   iso(format = 'date-time') {
     return this.clone({ format }).assert('format', (val, options) => {
       const { original } = options;
@@ -127,4 +146,7 @@ class DateSchema extends Schema {
   }
 }
 
+/**
+ * @type {() => DateSchema}
+ */
 export default wrapSchema(DateSchema);

package/src/index.js

@@ -5,14 +5,47 @@ 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 Schema from './Schema';
+import { isSchema, isSchemaError } from './utils';
+import { useLocalizer, getLocalizedMessages } from './localization';
 import { LocalizedError } from './errors';
 
-const allow = wrapArgs('allow');
-const reject = wrapArgs('reject');
-const custom = wrapArgs('custom');
-const any = wrapAny();
+function any() {
+  return new Schema();
+}
+
+function allow(...args) {
+  return new Schema().allow(...args);
+}
+
+function reject(...args) {
+  return new Schema().reject(...args);
+}
+
+/**
+ * @param {import("./Schema").CustomSignature} args
+ */
+function custom(...args) {
+  return new Schema().custom(...args);
+}
+
+export {
+  array,
+  boolean,
+  date,
+  number,
+  object,
+  string,
+  any,
+  allow,
+  reject,
+  custom,
+  isSchema,
+  isSchemaError,
+  useLocalizer,
+  getLocalizedMessages,
+  LocalizedError,
+};
 
 export default {
   array,
@@ -28,6 +61,6 @@ export default {
   isSchema,
   isSchemaError,
   useLocalizer,
-  getLocalizerTemplates,
+  getLocalizedMessages,
   LocalizedError,
 };

package/src/localization.js

@@ -1,38 +1,52 @@
 const TOKEN_REG = /{(.+?)}/g;
 
 let localizer;
-let templates = {};
 
+/**
+ * @type {{ [key: string]: string }}
+ */
+let messages = {};
+
+/**
+ * @param {{ [key: string]: string } | ((key: string) => string)} arg
+ * An object that maps messages to localized strings or a function that
+ * accepts a message and returns a localized string. Use "getLocalizedMessages"
+ * to see the messages that exist.
+ */
 export function useLocalizer(arg) {
-  const fn = typeof arg === 'function' ? arg : (template) => arg[template];
+  const fn = typeof arg === 'function' ? arg : (message) => arg[message];
   localizer = fn;
-  templates = {};
+  messages = {};
 }
 
-export function getLocalized(template) {
+export function getLocalized(message) {
   if (localizer) {
-    return localizer(template);
+    return localizer(message);
   }
 }
 
-export function localize(template, values = {}) {
-  let message = template;
-  if (localizer) {
-    let localized = getLocalized(template);
+export function localize(message, values = {}) {
+  let str = message;
+  if (str) {
+    let localized = getLocalized(message);
     if (typeof localized === 'function') {
       localized = localized(values);
     }
     if (localized) {
-      message = localized;
+      str = localized;
     }
   }
-  templates[template] = message;
+  messages[message] = str;
 
-  return message.replace(TOKEN_REG, (match, token) => {
+  return str.replace(TOKEN_REG, (match, token) => {
     return token in values ? values[token] : match;
   });
 }
 
-export function getLocalizerTemplates() {
-  return templates;
+/**
+ * Returns an object containing all encountered messages
+ * mapped to their localizations.
+ */
+export function getLocalizedMessages() {
+  return messages;
 }

package/src/number.js

@@ -16,22 +16,28 @@ class NumberSchema extends TypeSchema {
     });
   }
 
-  min(min, msg) {
-    msg ||= 'Must be greater than {min}.';
+  /**
+   * @param {number} min
+   * @param {string} message
+   */
+  min(min, message = 'Must be greater than {min}.') {
     return this.clone({ min }).assert('min', (num) => {
       if (num < min) {
-        throw new LocalizedError(msg, {
+        throw new LocalizedError(message, {
           min,
         });
       }
     });
   }
 
-  max(max, msg) {
-    msg ||= 'Must be less than {max}.';
+  /**
+   * @param {number} max
+   * @param {string} message
+   */
+  max(max, message = 'Must be less than {max}.') {
     return this.clone({ max }).assert('max', (num) => {
       if (num > max) {
-        throw new LocalizedError(msg, {
+        throw new LocalizedError(message, {
           max,
         });
       }
@@ -81,4 +87,7 @@ class NumberSchema extends TypeSchema {
   }
 }
 
+/**
+ * @type {() => NumberSchema}
+ */
 export default wrapSchema(NumberSchema);

package/src/object.js

@@ -11,6 +11,9 @@ class ObjectSchema extends TypeSchema {
     this.setup();
   }
 
+  /**
+   * @private
+   */
   setup() {
     this.assert('type', (val) => {
       if (val === null || typeof val !== 'object') {
@@ -76,6 +79,10 @@ class ObjectSchema extends TypeSchema {
     }
   }
 
+  /**
+   * @param {object|ObjectSchema} arg
+   * @returns Schema
+   */
   append(arg) {
     let schema;
     if (arg instanceof ObjectSchema) {
@@ -124,4 +131,7 @@ class ObjectSchema extends TypeSchema {
   }
 }
 
+/**
+ * @type {(arg: object) => ObjectSchema}
+ */
 export default wrapSchema(ObjectSchema);

package/src/string.js

@@ -28,6 +28,9 @@ class StringSchema extends TypeSchema {
     });
   }
 
+  /**
+   * @param {number} length
+   */
   min(length) {
     return this.clone({ min: length }).assert('length', (str) => {
       if (str && str.length < length) {
@@ -38,6 +41,9 @@ class StringSchema extends TypeSchema {
     });
   }
 
+  /**
+   * @param {number} length
+   */
   max(length) {
     return this.clone({ max: length }).assert('length', (str) => {
       if (str && str.length > length) {
@@ -54,6 +60,9 @@ class StringSchema extends TypeSchema {
     });
   }
 
+  /**
+   * @param {boolean} [assert] Throws an error if not lowercase. Default: `false`.
+   */
   lowercase(assert = false) {
     return this.clone().transform((str) => {
       const lower = str.toLowerCase();
@@ -66,6 +75,9 @@ class StringSchema extends TypeSchema {
     });
   }
 
+  /**
+   * @param {boolean} [assert] Throws an error if not uppercase. Default: `false`.
+   */
   uppercase(assert = false) {
     return this.clone().transform((str) => {
       const upper = str.toUpperCase();
@@ -78,6 +90,9 @@ class StringSchema extends TypeSchema {
     });
   }
 
+  /**
+   * @param {RegExp} reg
+   */
   match(reg) {
     if (!(reg instanceof RegExp)) {
       throw new LocalizedError('Argument must be a regular expression');
@@ -139,6 +154,10 @@ class StringSchema extends TypeSchema {
     });
   }
 
+  /**
+   * @param {Object} [options]
+   * @param {boolean} [options.urlSafe]
+   */
   base64(options) {
     return this.format('base64', (str) => {
       if (!validator.isBase64(str, options)) {
@@ -204,6 +223,9 @@ class StringSchema extends TypeSchema {
     });
   }
 
+  /**
+   * @param {string} locale
+   */
   postalCode(locale = 'any') {
     return this.format('postal-code', (str) => {
       if (!validator.isPostalCode(str, locale)) {
@@ -212,8 +234,16 @@ class StringSchema extends TypeSchema {
     });
   }
 
+  /**
+   * @param {Object} [options]
+   * @param {number} [options.minLength]
+   * @param {number} [options.minNumbers]
+   * @param {number} [options.minSymbols]
+   * @param {number} [options.minLowercase]
+   * @param {number} [options.minUppercase]
+   */
   password(options = {}) {
-    const { minLength, minLowercase, minUppercase, minNumbers, minSymbols } = {
+    const { minLength, minNumbers, minSymbols, minLowercase, minUppercase } = {
       ...PASSWORD_DEFAULTS,
       ...options,
     };
@@ -239,6 +269,18 @@ class StringSchema extends TypeSchema {
     return schema;
   }
 
+  /**
+   * @param {Object} [options]
+   * @param {boolean} [options.require_protocol]
+   * @param {boolean} [options.require_valid_protocol]
+   * @param {boolean} [options.require_host]
+   * @param {boolean} [options.require_port]
+   * @param {boolean} [options.allow_protocol_relative_urls]
+   * @param {boolean} [options.allow_fragments]
+   * @param {boolean} [options.allow_query_components]
+   * @param {boolean} [options.validate_length]
+   * @param {string[]} [options.protocols]
+   */
   url(options) {
     return this.format('url', (str) => {
       if (!validator.isURL(str, options)) {
@@ -247,6 +289,15 @@ class StringSchema extends TypeSchema {
     });
   }
 
+  /**
+   * @param {Object} [options]
+   * @param {boolean} [options.require_tld=true]
+   * @param {boolean} [options.allow_underscores=false]
+   * @param {boolean} [options.allow_trailing_dot=false]
+   * @param {boolean} [options.allow_numeric_tld=false]
+   * @param {boolean} [options.allow_wildcard=false]
+   * @param {boolean} [options.ignore_max_length=false]
+   */
   domain(options) {
     return this.format('domain', (str) => {
       if (!validator.isFQDN(str, options)) {
@@ -255,6 +306,9 @@ class StringSchema extends TypeSchema {
     });
   }
 
+  /**
+   * @param {1 | 2 | 3 | 4 | 5} [version] Version of UUID to check.
+   */
   uuid(version) {
     return this.format('uuid', (str) => {
       if (!validator.isUUID(str, version)) {
@@ -309,4 +363,7 @@ class StringSchema extends TypeSchema {
   }
 }
 
+/**
+ * @type {() => StringSchema}
+ */
 export default wrapSchema(StringSchema);

package/src/utils.js

@@ -1,22 +1,8 @@
-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';

package/types/Schema.d.ts

@@ -0,0 +1,49 @@
+export function isSchema(arg: any): boolean;
+/**
+ * @typedef {[fn: Function] | [type: string, fn: Function]} CustomSignature
+ */
+export default class Schema {
+    constructor(meta?: {});
+    assertions: any[];
+    meta: {};
+    required(): Schema;
+    default(value: any): Schema;
+    /**
+     * @param {CustomSignature} args
+     */
+    custom(...args: CustomSignature): Schema;
+    strip(strip: any): Schema;
+    allow(...set: any[]): Schema;
+    reject(...set: any[]): Schema;
+    message(message: any): Schema;
+    tag(tags: any): Schema;
+    description(description: any): Schema;
+    options(options: any): Schema;
+    validate(value: any, options?: {}): Promise<any>;
+    /**
+     * @returns {this}
+     */
+    clone(meta: any): this;
+    /**
+     * @returns {Schema}
+     */
+    append(schema: any): Schema;
+    toOpenApi(extra: any): any;
+    assertEnum(set: any, allow: any): Schema;
+    assert(type: any, fn: any): Schema;
+    pushAssertion(assertion: any): void;
+    transform(fn: any): Schema;
+    getSortIndex(type: any): number;
+    runAssertion(assertion: any, value: any, options?: {}): Promise<any>;
+    enumToOpenApi(): {
+        type: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        enum: any;
+        oneOf?: undefined;
+    } | {
+        oneOf: any[];
+        type?: undefined;
+        enum?: undefined;
+    };
+}
+export type CustomSignature = [fn: Function] | [type: string, fn: Function];
+//# sourceMappingURL=Schema.d.ts.map

package/types/Schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schema.d.ts","sourceRoot":"","sources":["../src/Schema.js"],"names":[],"mappings":"AAgSA,4CAEC;AAvRD;;GAEG;AAEH;IACE,uBAGC;IAFC,kBAAoB;IACpB,SAAgB;IAKlB,mBAMC;IAED,4BAMC;IAED;;OAEG;IACH,gBAFW,eAAe,UAmBzB;IAED,0BAEC;IAED,6BAEC;IAED,8BAEC;IAED,8BAEC;IAED,uBAOC;IAED,sCAIC;IAED,8BAEC;IAED,iDAqCC;IAED;;OAEG;IACH,kBAFa,IAAI,CAOhB;IAED;;OAEG;IACH,qBAFa,MAAM,CAMlB;IAED,2BAgBC;IAID,yCA8BC;IAED,mCAQC;IAED,oCAKC;IAED,2BAOC;IAED,gCAGC;IAED,qEAUC;IAED;;;;;;;;MAoCC;CACF;8BAlRY,CAAC,EAAE,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,UAAU,CAAC"}

package/types/TypeSchema.d.ts

@@ -0,0 +1,7 @@
+export default class TypeSchema extends Schema {
+    constructor(Class: any, meta: any);
+    format(name: any, fn: any): TypeSchema;
+    toString(): any;
+}
+import Schema from "./Schema";
+//# sourceMappingURL=TypeSchema.d.ts.map