@bedrockio/yada 1.0.16 → 1.0.17

package/README.md

@@ -15,6 +15,7 @@ Concepts
   - [Number](#number)
   - [Boolean](#boolean)
   - [Array](#array)
+  - [Tuple](#tuple)
   - [Object](#object)
   - [Date](#date)
 - [Common Methods](#common-methods)
@@ -254,12 +255,28 @@ const schema = yd.array([schemas]);
 
 #### Methods:
 
-- `max` - Length must be less than equal to `n` characters, passed as an
-  argument.
-- `min` - Length must be more than or equal to `n` characters, passed as an
+- `max` - Length must be less than equal to `n` elements.
+- `min` - Length must be more than or equal to `n` elements.
+- `length` - Length must be exactly `n` elements.
 - `latlng` - Must be a 2 element array of numbers that represent latitude (`-90`
   to `90`) and longitude(`-180` to `180`) coordinates.
 
+### Tuple
+
+Tuple schemas are similar to arrays, however they validate the exact length as
+well as types for a given position. Compare the following:
+
+```js
+// Accepts any length of either strings or numbers.
+const schema1 = yd.array(yd.string(), yd.number());
+// Accepts exactly 2 elements. The first MUST be a
+// string and the second MUST be a number.
+const schema2 = yd.tuple(yd.string(), yd.number());
+```
+
+Tuples are appropriate for strictly structured arrays, for example an array of
+coordinates as latitude and longitude.
+
 ## Object
 
 Object schemas validate that input is an object and further validate individual

package/dist/cjs/index.js

@@ -68,18 +68,25 @@ Object.defineProperty(exports, "string", {
     return _string.default;
   }
 });
+Object.defineProperty(exports, "tuple", {
+  enumerable: true,
+  get: function () {
+    return _tuple.default;
+  }
+});
 Object.defineProperty(exports, "useLocalizer", {
   enumerable: true,
   get: function () {
     return _localization.useLocalizer;
   }
 });
-var _array = _interopRequireDefault(require("./array"));
+var _string = _interopRequireDefault(require("./string"));
+var _number = _interopRequireDefault(require("./number"));
 var _boolean = _interopRequireDefault(require("./boolean"));
 var _date = _interopRequireDefault(require("./date"));
-var _number = _interopRequireDefault(require("./number"));
 var _object = _interopRequireDefault(require("./object"));
-var _string = _interopRequireDefault(require("./string"));
+var _array = _interopRequireDefault(require("./array"));
+var _tuple = _interopRequireDefault(require("./tuple"));
 var _Schema = _interopRequireDefault(require("./Schema"));
 var _utils = require("./utils");
 var _localization = require("./localization");
@@ -120,6 +127,7 @@ var _default = {
   number: _number.default,
   object: _object.default,
   string: _string.default,
+  tuple: _tuple.default,
   any,
   allow,
   reject,

package/dist/cjs/tuple.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _Schema = _interopRequireDefault(require("./Schema"));
+var _errors = require("./errors");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class TupleSchema extends _Schema.default {
+  constructor(schemas) {
+    super({
+      message: 'Tuple failed validation.',
+      schemas
+    });
+    this.setup();
+  }
+
+  /**
+   * @private
+   */
+  setup() {
+    const {
+      schemas
+    } = this.meta;
+    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;
+    });
+    this.assert('length', val => {
+      const {
+        length
+      } = schemas;
+      if (val.length !== length) {
+        throw new _errors.LocalizedError('Tuple must be exactly {length} elements.', {
+          length: schemas.length
+        });
+      }
+      return val;
+    });
+    this.assert('elements', async (arr, options) => {
+      const errors = [];
+      const result = [];
+      for (let i = 0; i < schemas.length; i++) {
+        const schema = schemas[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;
+      }
+    });
+  }
+  toString() {
+    return 'tuple';
+  }
+  toOpenApi(extra) {
+    const {
+      schemas
+    } = this.meta;
+    return {
+      type: 'array',
+      ...super.toOpenApi(extra),
+      prefixItems: schemas.map(schema => {
+        return schema.toOpenApi();
+      })
+    };
+  }
+}
+
+/**
+ * Creates a [tuple schema](https://github.com/bedrockio/yada#tuple).
+ *
+ * @param {...Schema} [schemas] Schemas to validate
+ * the exact types of elements allowed in the tuple. Also
+ * accepts a single array argument.
+ */
+function _default(...schemas) {
+  if (Array.isArray(schemas[0])) {
+    schemas = schemas[0];
+  }
+  return new TupleSchema(schemas);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/yada",
-  "version": "1.0.16",
+  "version": "1.0.17",
   "description": "Validation library inspired by Joi.",
   "scripts": {
     "test": "jest",

package/src/index.js

@@ -1,9 +1,10 @@
-import array from './array';
+import string from './string';
+import number from './number';
 import boolean from './boolean';
 import date from './date';
-import number from './number';
 import object from './object';
-import string from './string';
+import array from './array';
+import tuple from './tuple';
 
 import Schema from './Schema';
 import { isSchema, isSchemaError } from './utils';
@@ -46,6 +47,7 @@ export {
   number,
   object,
   string,
+  tuple,
   any,
   allow,
   reject,
@@ -64,6 +66,7 @@ export default {
   number,
   object,
   string,
+  tuple,
   any,
   allow,
   reject,

package/src/tuple.js

@@ -0,0 +1,91 @@
+import Schema from './Schema';
+import { ArrayError, ElementError, LocalizedError } from './errors';
+
+class TupleSchema extends Schema {
+  constructor(schemas) {
+    super({ message: 'Tuple failed validation.', schemas });
+    this.setup();
+  }
+
+  /**
+   * @private
+   */
+  setup() {
+    const { schemas } = this.meta;
+
+    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;
+    });
+
+    this.assert('length', (val) => {
+      const { length } = schemas;
+      if (val.length !== length) {
+        throw new LocalizedError('Tuple must be exactly {length} elements.', {
+          length: schemas.length,
+        });
+      }
+      return val;
+    });
+
+    this.assert('elements', async (arr, options) => {
+      const errors = [];
+      const result = [];
+
+      for (let i = 0; i < schemas.length; i++) {
+        const schema = schemas[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;
+      }
+    });
+  }
+
+  toString() {
+    return 'tuple';
+  }
+
+  toOpenApi(extra) {
+    const { schemas } = this.meta;
+    return {
+      type: 'array',
+      ...super.toOpenApi(extra),
+      prefixItems: schemas.map((schema) => {
+        return schema.toOpenApi();
+      }),
+    };
+  }
+}
+
+/**
+ * Creates a [tuple schema](https://github.com/bedrockio/yada#tuple).
+ *
+ * @param {...Schema} [schemas] Schemas to validate
+ * the exact types of elements allowed in the tuple. Also
+ * accepts a single array argument.
+ */
+export default function (...schemas) {
+  if (Array.isArray(schemas[0])) {
+    schemas = schemas[0];
+  }
+  return new TupleSchema(schemas);
+}

package/types/index.d.ts

@@ -5,6 +5,7 @@ declare namespace _default {
     export { number };
     export { object };
     export { string };
+    export { tuple };
     export { any };
     export { allow };
     export { reject };
@@ -22,6 +23,7 @@ import date from "./date";
 import number from "./number";
 import object from "./object";
 import string from "./string";
+import tuple from "./tuple";
 /**
  * Accepts anything.
  */
@@ -45,5 +47,5 @@ import { useLocalizer } from "./localization";
 import { getLocalizedMessages } from "./localization";
 import { LocalizedError } from "./errors";
 import Schema from "./Schema";
-export { array, boolean, date, number, object, string, isSchema, isSchemaError, useLocalizer, getLocalizedMessages, LocalizedError };
+export { array, boolean, date, number, object, string, tuple, isSchema, isSchemaError, useLocalizer, getLocalizedMessages, LocalizedError };
 //# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAYA;;GAEG;AACH,8BAEC;AAED;;GAEG;AACH,8CAEC;AAED;;GAEG;AACH,+CAEC;AAED;;;GAGG;AACH,gCAFW,OAAO,UAAU,EAAE,eAAe,UAI5C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAaA;;GAEG;AACH,8BAEC;AAED;;GAEG;AACH,8CAEC;AAED;;GAEG;AACH,+CAEC;AAED;;;GAGG;AACH,gCAFW,OAAO,UAAU,EAAE,eAAe,UAI5C"}

package/types/tuple.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Creates a [tuple schema](https://github.com/bedrockio/yada#tuple).
+ *
+ * @param {...Schema} [schemas] Schemas to validate
+ * the exact types of elements allowed in the tuple. Also
+ * accepts a single array argument.
+ */
+export default function _default(...schemas?: Schema[]): TupleSchema;
+import Schema from "./Schema";
+declare class TupleSchema extends Schema {
+    constructor(schemas: any);
+    /**
+     * @private
+     */
+    private setup;
+}
+export {};
+//# sourceMappingURL=tuple.d.ts.map

package/types/tuple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["../src/tuple.js"],"names":[],"mappings":"AA8EA;;;;;;GAMG;AACH,8CAJc,MAAM,iBASnB;;AAvFD;IACE,0BAGC;IAED;;OAEG;IACH,cAgDC;CAgBF"}