@bedrockio/model 0.12.1 → 0.12.3

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.12.3
+
+- Support for `include` with top level dynamic references.
+
+## 0.12.2
+
+- Updated validators for string ranges.
+
 ## 0.12.1
 
 - Allow range-based search on string fields.

package/README.md

@@ -597,9 +597,9 @@ advanced features:
 
 will be flattened to:
 
-```
+```json
 {
-  'profile.age': 20
+  "profile.age": 20
 }
 ```
 
@@ -609,7 +609,7 @@ Passing an array to `search` will perform a query using `$in`, which matches on
 the intersection of any elements. For example,
 
 ```json
-tags: ["one", "two"]
+"tags": ["one", "two"]
 ```
 
 is effectively saying "match any documents whose `tags` array contains any of
@@ -652,9 +652,9 @@ match.
 Additionally, date and number fields allow range queries in the form:
 
 ```json
-age: {
-  gt: 1
-  lt: 2
+"age": {
+  "gt": 1,
+  "lt": 2
 }
 ```
 
@@ -1050,6 +1050,10 @@ await Product.findById(id).include('shop.user.^name').
 }
 ```
 
+> [!WARNING] Fields that are dynamically referenced using `refPath` are unable
+> to resolve the schemas beforehand (ie. before query execution), therefore they
+> can only be populated at the top level.
+
 #### Excluded Fields
 
 Fields can be excluded rather than included using `-`:

package/dist/cjs/include.js

@@ -325,6 +325,12 @@ function setNodePath(node, options) {
             exclusive
           });
           halt = true;
+        } else if (field.refPath) {
+          // Note that dynamic references with refPath cannot "see"
+          // into a field for which they don't know the type yet (ie.
+          // before the query executes), therefore by definition
+          // dynamic references can only be populated one layer deep.
+          node[key] ||= {};
         } else if ((0, _utils.isSchemaTypedef)(field)) {
           node[key] = LEAF_NODE;
         }

package/dist/cjs/search.js

@@ -11,7 +11,7 @@ var _mongoose = _interopRequireDefault(require("mongoose"));
 var _lodash = require("lodash");
 var _utils = require("./utils");
 var _const = require("./const");
-var _validation = require("./validation");
+var _validationSchemas = require("./validation-schemas");
 var _env = require("./env");
 var _query = require("./query");
 var _warn = _interopRequireDefault(require("./warn"));
@@ -49,7 +49,7 @@ function searchValidation(options = {}) {
     sort
   } = searchOptions;
   return _yada.default.object({
-    ids: _yada.default.array(_validation.OBJECT_ID_SCHEMA),
+    ids: _yada.default.array(_validationSchemas.OBJECT_ID_SCHEMA),
     keyword: _yada.default.string().description('A keyword to perform a text search against.'),
     skip: _yada.default.number().default(0).description('Number of records to skip.'),
     sort: getSortSchema(sort),

package/dist/cjs/validation-schemas.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.STRING_RANGE_SCHEMA = exports.REFERENCE_SCHEMA = exports.OBJECT_ID_SCHEMA = exports.NUMBER_RANGE_SCHEMA = exports.DATE_SCHEMA = exports.DATE_RANGE_SCHEMA = void 0;
+var _yada = _interopRequireDefault(require("@bedrockio/yada"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const DATE_TAGS = {
+  'x-schema': 'DateTime',
+  'x-description': 'A `string` in [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html) format.'
+};
+const DATE_SCHEMA = exports.DATE_SCHEMA = _yada.default.date().iso().tag(DATE_TAGS);
+const OBJECT_ID_SCHEMA = exports.OBJECT_ID_SCHEMA = _yada.default.string().mongo().message('Must be a valid object id.').tag({
+  'x-schema': 'ObjectId',
+  'x-description': 'A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).'
+});
+const NUMBER_RANGE_SCHEMA = exports.NUMBER_RANGE_SCHEMA = _yada.default.object({
+  lt: _yada.default.number().description('Select values less than.'),
+  gt: _yada.default.number().description('Select values greater than.'),
+  lte: _yada.default.number().description('Select values less than or equal.'),
+  gte: _yada.default.number().description('Select values greater than or equal.')
+}).tag({
+  'x-schema': 'NumberRange',
+  'x-description': 'An object representing numbers falling within a range.'
+});
+const STRING_RANGE_SCHEMA = exports.STRING_RANGE_SCHEMA = _yada.default.object({
+  lt: _yada.default.string().description('Select values less than.'),
+  gt: _yada.default.string().description('Select values greater than.'),
+  lte: _yada.default.string().description('Select values less than or equal.'),
+  gte: _yada.default.string().description('Select values greater than or equal.')
+}).tag({
+  'x-schema': 'StringRange',
+  'x-description': 'An object representing strings falling within a range.'
+});
+const DATE_RANGE_SCHEMA = exports.DATE_RANGE_SCHEMA = _yada.default.object({
+  lt: _yada.default.date().iso().tag({
+    ...DATE_TAGS,
+    description: 'Select dates occurring before.'
+  }),
+  gt: _yada.default.date().iso().tag({
+    ...DATE_TAGS,
+    description: 'Select dates occurring after.'
+  }),
+  lte: _yada.default.date().iso().tag({
+    ...DATE_TAGS,
+    description: 'Select dates occurring on or before.'
+  }),
+  gte: _yada.default.date().iso().tag({
+    ...DATE_TAGS,
+    description: 'Select dates occurring on or after.'
+  })
+}).tag({
+  'x-schema': 'DateRange',
+  'x-description': 'An object representing dates falling within a range.'
+});
+const REFERENCE_SCHEMA = exports.REFERENCE_SCHEMA = _yada.default.allow(OBJECT_ID_SCHEMA, _yada.default.object({
+  id: OBJECT_ID_SCHEMA.required()
+}).options({
+  stripUnknown: true
+}).custom(obj => {
+  return obj.id;
+})).message('Must be an id or object containing an "id" field.').tag({
+  'x-schema': 'Reference',
+  'x-description': `
+A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).
+An object with an \`id\` field may also be passed, which will be converted into a string.
+    `.trim()
+});

package/dist/cjs/validation.js

@@ -3,7 +3,6 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.OBJECT_ID_SCHEMA = void 0;
 exports.addValidators = addValidators;
 exports.applyValidation = applyValidation;
 exports.getNamedValidator = getNamedValidator;
@@ -18,35 +17,15 @@ var _softDelete = require("./soft-delete");
 var _errors = require("./errors");
 var _utils = require("./utils");
 var _include = require("./include");
+var _validationSchemas = require("./validation-schemas");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const DATE_TAGS = {
-  'x-schema': 'DateTime',
-  'x-description': 'A `string` in [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html) format.'
-};
-const OBJECT_ID_SCHEMA = exports.OBJECT_ID_SCHEMA = _yada.default.string().mongo().message('Must be a valid object id.').tag({
-  'x-schema': 'ObjectId',
-  'x-description': 'A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).'
-});
-const REFERENCE_SCHEMA = _yada.default.allow(OBJECT_ID_SCHEMA, _yada.default.object({
-  id: OBJECT_ID_SCHEMA.required()
-}).options({
-  stripUnknown: true
-}).custom(obj => {
-  return obj.id;
-})).message('Must be an id or object containing an "id" field.').tag({
-  'x-schema': 'Reference',
-  'x-description': `
-A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).
-An object with an \`id\` field may also be passed, which will be converted into a string.
-    `.trim()
-});
 const NAMED_SCHEMAS = {
   // Email is special as we are assuming that in
   // all cases lowercase should be allowed but coerced.
   email: _yada.default.string().lowercase().email(),
   // Force "objectId" to have parity with refs.
   // "mongo" is notably excluded here for this reason.
-  objectId: OBJECT_ID_SCHEMA,
+  objectId: _validationSchemas.OBJECT_ID_SCHEMA,
   ascii: _yada.default.string().ascii(),
   base64: _yada.default.string().base64(),
   btc: _yada.default.string().btc(),
@@ -356,7 +335,7 @@ function getSchemaForType(type, options) {
     case 'Boolean':
       return _yada.default.boolean();
     case 'Date':
-      return _yada.default.date().iso().tag(DATE_TAGS);
+      return _validationSchemas.DATE_SCHEMA;
     case 'Object':
       return _yada.default.object();
     case 'Array':
@@ -365,48 +344,22 @@ function getSchemaForType(type, options) {
       return _yada.default.any();
     case 'ObjectId':
       if (options.allowExpandedRefs) {
-        return REFERENCE_SCHEMA;
+        return _validationSchemas.REFERENCE_SCHEMA;
       } else {
-        return OBJECT_ID_SCHEMA;
+        return _validationSchemas.OBJECT_ID_SCHEMA;
       }
     default:
       throw new TypeError(`Unknown schema type ${type}`);
   }
 }
 function getSearchSchema(schema, type) {
-  if (type === 'Number') {
-    return _yada.default.allow(schema, _yada.default.array(schema), _yada.default.object({
-      lt: _yada.default.number().description('Select values less than.'),
-      gt: _yada.default.number().description('Select values greater than.'),
-      lte: _yada.default.number().description('Select values less than or equal.'),
-      gte: _yada.default.number().description('Select values greater than or equal.')
-    }).tag({
-      'x-schema': 'NumberRange',
-      'x-description': 'An object representing numbers falling within a range.'
-    })).description('Allows searching by a value, array of values, or a numeric range.');
+  if (type === 'String') {
+    return _yada.default.allow(schema, _yada.default.array(schema), _validationSchemas.STRING_RANGE_SCHEMA).description('Allows searching by a string, array of strings, or a range.');
+  } else if (type === 'Number') {
+    return _yada.default.allow(schema, _yada.default.array(schema), _validationSchemas.NUMBER_RANGE_SCHEMA).description('Allows searching by a value, array of values, or a  range.');
   } else if (type === 'Date') {
-    return _yada.default.allow(schema, _yada.default.array(schema), _yada.default.object({
-      lt: _yada.default.date().iso().tag({
-        ...DATE_TAGS,
-        description: 'Select dates occurring before.'
-      }),
-      gt: _yada.default.date().iso().tag({
-        ...DATE_TAGS,
-        description: 'Select dates occurring after.'
-      }),
-      lte: _yada.default.date().iso().tag({
-        ...DATE_TAGS,
-        description: 'Select dates occurring on or before.'
-      }),
-      gte: _yada.default.date().iso().tag({
-        ...DATE_TAGS,
-        description: 'Select dates occurring on or after.'
-      })
-    }).tag({
-      'x-schema': 'DateRange',
-      'x-description': 'An object representing dates falling within a range.'
-    })).description('Allows searching by a date, array of dates, or a range.');
-  } else if (type === 'String' || type === 'ObjectId') {
+    return _yada.default.allow(schema, _yada.default.array(schema), _validationSchemas.DATE_RANGE_SCHEMA).description('Allows searching by a date, array of dates, or a range.');
+  } else if (type === 'ObjectId') {
     return _yada.default.allow(schema, _yada.default.array(schema));
   } else {
     return schema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.12.1",
+  "version": "0.12.3",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {

package/src/include.js

@@ -233,6 +233,7 @@ function setNodePath(node, options) {
   }
 
   const schema = mongoose.models[modelName]?.schema;
+
   if (!schema) {
     throw new Error(`Could not derive schema for ${modelName}.`);
   }
@@ -318,6 +319,12 @@ function setNodePath(node, options) {
             exclusive,
           });
           halt = true;
+        } else if (field.refPath) {
+          // Note that dynamic references with refPath cannot "see"
+          // into a field for which they don't know the type yet (ie.
+          // before the query executes), therefore by definition
+          // dynamic references can only be populated one layer deep.
+          node[key] ||= {};
         } else if (isSchemaTypedef(field)) {
           node[key] = LEAF_NODE;
         }

package/src/search.js

@@ -13,7 +13,7 @@ import {
 } from './utils';
 
 import { SEARCH_DEFAULTS } from './const';
-import { OBJECT_ID_SCHEMA } from './validation';
+import { OBJECT_ID_SCHEMA } from './validation-schemas';
 import { debug } from './env';
 import { mergeQuery, wrapQuery } from './query';
 

package/src/validation-schemas.js

@@ -0,0 +1,102 @@
+import yd from '@bedrockio/yada';
+
+const DATE_TAGS = {
+  'x-schema': 'DateTime',
+  'x-description':
+    'A `string` in [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html) format.',
+};
+
+export const DATE_SCHEMA = yd.date().iso().tag(DATE_TAGS);
+
+export const OBJECT_ID_SCHEMA = yd
+  .string()
+  .mongo()
+  .message('Must be a valid object id.')
+  .tag({
+    'x-schema': 'ObjectId',
+    'x-description':
+      'A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).',
+  });
+
+export const NUMBER_RANGE_SCHEMA = yd
+  .object({
+    lt: yd.number().description('Select values less than.'),
+    gt: yd.number().description('Select values greater than.'),
+    lte: yd.number().description('Select values less than or equal.'),
+    gte: yd.number().description('Select values greater than or equal.'),
+  })
+  .tag({
+    'x-schema': 'NumberRange',
+    'x-description': 'An object representing numbers falling within a range.',
+  });
+
+export const STRING_RANGE_SCHEMA = yd
+  .object({
+    lt: yd.string().description('Select values less than.'),
+    gt: yd.string().description('Select values greater than.'),
+    lte: yd.string().description('Select values less than or equal.'),
+    gte: yd.string().description('Select values greater than or equal.'),
+  })
+  .tag({
+    'x-schema': 'StringRange',
+    'x-description': 'An object representing strings falling within a range.',
+  });
+
+export const DATE_RANGE_SCHEMA = yd
+  .object({
+    lt: yd
+      .date()
+      .iso()
+      .tag({
+        ...DATE_TAGS,
+        description: 'Select dates occurring before.',
+      }),
+    gt: yd
+      .date()
+      .iso()
+      .tag({
+        ...DATE_TAGS,
+        description: 'Select dates occurring after.',
+      }),
+    lte: yd
+      .date()
+      .iso()
+      .tag({
+        ...DATE_TAGS,
+        description: 'Select dates occurring on or before.',
+      }),
+    gte: yd
+      .date()
+      .iso()
+      .tag({
+        ...DATE_TAGS,
+        description: 'Select dates occurring on or after.',
+      }),
+  })
+  .tag({
+    'x-schema': 'DateRange',
+    'x-description': 'An object representing dates falling within a range.',
+  });
+
+export const REFERENCE_SCHEMA = yd
+  .allow(
+    OBJECT_ID_SCHEMA,
+    yd
+      .object({
+        id: OBJECT_ID_SCHEMA.required(),
+      })
+      .options({
+        stripUnknown: true,
+      })
+      .custom((obj) => {
+        return obj.id;
+      }),
+  )
+  .message('Must be an id or object containing an "id" field.')
+  .tag({
+    'x-schema': 'Reference',
+    'x-description': `
+A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).
+An object with an \`id\` field may also be passed, which will be converted into a string.
+    `.trim(),
+  });

package/src/validation.js

@@ -9,45 +9,14 @@ import { assertUnique } from './soft-delete';
 import { PermissionsError, ImplementationError } from './errors';
 import { isMongooseSchema, isSchemaTypedef } from './utils';
 import { INCLUDE_FIELD_SCHEMA } from './include';
-
-const DATE_TAGS = {
-  'x-schema': 'DateTime',
-  'x-description':
-    'A `string` in [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html) format.',
-};
-
-export const OBJECT_ID_SCHEMA = yd
-  .string()
-  .mongo()
-  .message('Must be a valid object id.')
-  .tag({
-    'x-schema': 'ObjectId',
-    'x-description':
-      'A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).',
-  });
-
-const REFERENCE_SCHEMA = yd
-  .allow(
-    OBJECT_ID_SCHEMA,
-    yd
-      .object({
-        id: OBJECT_ID_SCHEMA.required(),
-      })
-      .options({
-        stripUnknown: true,
-      })
-      .custom((obj) => {
-        return obj.id;
-      }),
-  )
-  .message('Must be an id or object containing an "id" field.')
-  .tag({
-    'x-schema': 'Reference',
-    'x-description': `
-A 24 character hexadecimal string representing a Mongo [ObjectId](https://bit.ly/3YPtGlU).
-An object with an \`id\` field may also be passed, which will be converted into a string.
-    `.trim(),
-  });
+import {
+  DATE_SCHEMA,
+  REFERENCE_SCHEMA,
+  OBJECT_ID_SCHEMA,
+  NUMBER_RANGE_SCHEMA,
+  STRING_RANGE_SCHEMA,
+  DATE_RANGE_SCHEMA,
+} from './validation-schemas';
 
 const NAMED_SCHEMAS = {
   // Email is special as we are assuming that in
@@ -377,7 +346,7 @@ function getSchemaForType(type, options) {
     case 'Boolean':
       return yd.boolean();
     case 'Date':
-      return yd.date().iso().tag(DATE_TAGS);
+      return DATE_SCHEMA;
     case 'Object':
       return yd.object();
     case 'Array':
@@ -396,73 +365,23 @@ function getSchemaForType(type, options) {
 }
 
 function getSearchSchema(schema, type) {
-  if (type === 'Number') {
+  if (type === 'String') {
+    return yd
+      .allow(schema, yd.array(schema), STRING_RANGE_SCHEMA)
+      .description(
+        'Allows searching by a string, array of strings, or a range.',
+      );
+  } else if (type === 'Number') {
     return yd
-      .allow(
-        schema,
-        yd.array(schema),
-        yd
-          .object({
-            lt: yd.number().description('Select values less than.'),
-            gt: yd.number().description('Select values greater than.'),
-            lte: yd.number().description('Select values less than or equal.'),
-            gte: yd
-              .number()
-              .description('Select values greater than or equal.'),
-          })
-          .tag({
-            'x-schema': 'NumberRange',
-            'x-description':
-              'An object representing numbers falling within a range.',
-          }),
-      )
+      .allow(schema, yd.array(schema), NUMBER_RANGE_SCHEMA)
       .description(
-        'Allows searching by a value, array of values, or a numeric range.',
+        'Allows searching by a value, array of values, or a  range.',
       );
   } else if (type === 'Date') {
     return yd
-      .allow(
-        schema,
-        yd.array(schema),
-        yd
-          .object({
-            lt: yd
-              .date()
-              .iso()
-              .tag({
-                ...DATE_TAGS,
-                description: 'Select dates occurring before.',
-              }),
-            gt: yd
-              .date()
-              .iso()
-              .tag({
-                ...DATE_TAGS,
-                description: 'Select dates occurring after.',
-              }),
-            lte: yd
-              .date()
-              .iso()
-              .tag({
-                ...DATE_TAGS,
-                description: 'Select dates occurring on or before.',
-              }),
-            gte: yd
-              .date()
-              .iso()
-              .tag({
-                ...DATE_TAGS,
-                description: 'Select dates occurring on or after.',
-              }),
-          })
-          .tag({
-            'x-schema': 'DateRange',
-            'x-description':
-              'An object representing dates falling within a range.',
-          }),
-      )
+      .allow(schema, yd.array(schema), DATE_RANGE_SCHEMA)
       .description('Allows searching by a date, array of dates, or a range.');
-  } else if (type === 'String' || type === 'ObjectId') {
+  } else if (type === 'ObjectId') {
     return yd.allow(schema, yd.array(schema));
   } else {
     return schema;

package/types/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAuBA,gEAaC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA4CwC,CAAC;;;;;;;;;;;;;;;;;EAnBxC"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAuBA,gEAaC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA4CgC,CAAC;;;;;;;;;;;;;;;;;EAnBhC"}

package/types/validation-schemas.d.ts

@@ -0,0 +1,303 @@
+export const DATE_SCHEMA: {
+    min(min: string | number | Date): /*elided*/ any;
+    max(max: string | number | Date): /*elided*/ any;
+    before(max: string | number | Date): /*elided*/ any;
+    after(min: string | number | Date): /*elided*/ any;
+    past(): /*elided*/ any;
+    future(): /*elided*/ any;
+    iso(format?: "date" | "date-time"): /*elided*/ any;
+    timestamp(): /*elided*/ any;
+    unix(): /*elided*/ any;
+    assertions: any[];
+    meta: {};
+    required(): /*elided*/ any;
+    default(arg: any): /*elided*/ any;
+    custom(fn: Function): /*elided*/ any;
+    missing(fn: Function): /*elided*/ any;
+    strip(strip: any): /*elided*/ any;
+    allow(...set: any[]): /*elided*/ any;
+    reject(...set: any[]): /*elided*/ any;
+    nullable(): /*elided*/ any;
+    message(message: any): /*elided*/ any;
+    tag(tags: any): /*elided*/ any;
+    description(description: any): /*elided*/ any;
+    options(options: any): /*elided*/ any;
+    validate(value: any, options?: {}): Promise<any>;
+    clone(meta: any): /*elided*/ any;
+    append(schema: any): import("@bedrockio/yada/types/Schema").default;
+    toOpenApi(extra: any): any;
+    getAnyType(): {
+        type: string[];
+    };
+    getDefault(): {
+        default?: undefined;
+    } | {
+        default: any;
+    };
+    getNullable(): {
+        nullable: boolean;
+    };
+    expandExtra(extra?: {}): {};
+    inspect(): string;
+    get(): void;
+    assertEnum(set: any, allow: any): /*elided*/ any;
+    assert(type: any, fn: any): /*elided*/ any;
+    pushAssertion(assertion: any): void;
+    canSkipAssertion(value: any, assertion: any, options: any): any;
+    transform(fn: any): /*elided*/ any;
+    getSortIndex(type: any): number;
+    runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
+    enumToOpenApi(): any;
+};
+export const OBJECT_ID_SCHEMA: {
+    required(): /*elided*/ any;
+    length(length: number): /*elided*/ any;
+    min(length: number): /*elided*/ any;
+    max(length: number): /*elided*/ any;
+    trim(): /*elided*/ any;
+    lowercase(assert?: boolean): /*elided*/ any;
+    uppercase(assert?: boolean): /*elided*/ any;
+    match(reg: RegExp): /*elided*/ any;
+    email(): /*elided*/ any;
+    phone(code: any): /*elided*/ any;
+    hex(): /*elided*/ any;
+    md5(): /*elided*/ any;
+    sha1(): /*elided*/ any;
+    ascii(): /*elided*/ any;
+    base64(options?: {
+        urlSafe?: boolean;
+    }): /*elided*/ any;
+    creditCard(): /*elided*/ any;
+    ip(): /*elided*/ any;
+    country(): /*elided*/ any;
+    locale(): /*elided*/ any;
+    jwt(): /*elided*/ any;
+    slug(): /*elided*/ any;
+    latlng(): /*elided*/ any;
+    postalCode(locale?: string): /*elided*/ any;
+    zipcode(): /*elided*/ any;
+    password(options?: {
+        minLength?: number;
+        minNumbers?: number;
+        minSymbols?: number;
+        minLowercase?: number;
+        minUppercase?: number;
+    }): /*elided*/ any;
+    url(options?: {
+        require_protocol?: boolean;
+        require_valid_protocol?: boolean;
+        require_host?: boolean;
+        require_port?: boolean;
+        allow_protocol_relative_urls?: boolean;
+        allow_fragments?: boolean;
+        allow_query_components?: boolean;
+        validate_length?: boolean;
+        protocols?: string[];
+    }): /*elided*/ any;
+    domain(options?: {
+        require_tld?: boolean;
+        allow_underscores?: boolean;
+        allow_trailing_dot?: boolean;
+        allow_numeric_tld?: boolean;
+        allow_wildcard?: boolean;
+        ignore_max_length?: boolean;
+    }): /*elided*/ any;
+    uuid(version?: 1 | 2 | 3 | 4 | 5): /*elided*/ any;
+    btc(): /*elided*/ any;
+    eth(): /*elided*/ any;
+    swift(): /*elided*/ any;
+    mongo(): /*elided*/ any;
+    format(name: any, fn: any): /*elided*/ any;
+    toString(): any;
+    assertions: any[];
+    meta: {};
+    default(arg: any): /*elided*/ any;
+    custom(fn: Function): /*elided*/ any;
+    missing(fn: Function): /*elided*/ any;
+    strip(strip: any): /*elided*/ any;
+    allow(...set: any[]): /*elided*/ any;
+    reject(...set: any[]): /*elided*/ any;
+    nullable(): /*elided*/ any;
+    message(message: any): /*elided*/ any;
+    tag(tags: any): /*elided*/ any;
+    description(description: any): /*elided*/ any;
+    options(options: any): /*elided*/ any;
+    validate(value: any, options?: {}): Promise<any>;
+    clone(meta: any): /*elided*/ any;
+    append(schema: any): import("@bedrockio/yada/types/Schema").default;
+    toOpenApi(extra: any): any;
+    getAnyType(): {
+        type: string[];
+    };
+    getDefault(): {
+        default?: undefined;
+    } | {
+        default: any;
+    };
+    getNullable(): {
+        nullable: boolean;
+    };
+    expandExtra(extra?: {}): {};
+    inspect(): string;
+    get(): void;
+    assertEnum(set: any, allow: any): /*elided*/ any;
+    assert(type: any, fn: any): /*elided*/ any;
+    pushAssertion(assertion: any): void;
+    canSkipAssertion(value: any, assertion: any, options: any): any;
+    transform(fn: any): /*elided*/ any;
+    getSortIndex(type: any): number;
+    runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
+    enumToOpenApi(): any;
+};
+export const NUMBER_RANGE_SCHEMA: {
+    setup(): void;
+    get(path?: string | Array<string>): any;
+    unwind(path?: string | Array<string>): any;
+    pick(...names?: string[]): /*elided*/ any;
+    omit(...names?: string[]): /*elided*/ any;
+    require(...fields: string[]): /*elided*/ any;
+    export(): any;
+    append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
+    format(name: any, fn: any): /*elided*/ any;
+    toString(): any;
+    assertions: any[];
+    meta: {};
+    required(): /*elided*/ any;
+    default(arg: any): /*elided*/ any;
+    custom(fn: Function): /*elided*/ any;
+    missing(fn: Function): /*elided*/ any;
+    strip(strip: any): /*elided*/ any;
+    allow(...set: any[]): /*elided*/ any;
+    reject(...set: any[]): /*elided*/ any;
+    nullable(): /*elided*/ any;
+    message(message: any): /*elided*/ any;
+    tag(tags: any): /*elided*/ any;
+    description(description: any): /*elided*/ any;
+    options(options: any): /*elided*/ any;
+    validate(value: any, options?: {}): Promise<any>;
+    clone(meta: any): /*elided*/ any;
+    toOpenApi(extra: any): any;
+    getAnyType(): {
+        type: string[];
+    };
+    getDefault(): {
+        default?: undefined;
+    } | {
+        default: any;
+    };
+    getNullable(): {
+        nullable: boolean;
+    };
+    expandExtra(extra?: {}): {};
+    inspect(): string;
+    assertEnum(set: any, allow: any): /*elided*/ any;
+    assert(type: any, fn: any): /*elided*/ any;
+    pushAssertion(assertion: any): void;
+    canSkipAssertion(value: any, assertion: any, options: any): any;
+    transform(fn: any): /*elided*/ any;
+    getSortIndex(type: any): number;
+    runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
+    enumToOpenApi(): any;
+};
+export const STRING_RANGE_SCHEMA: {
+    setup(): void;
+    get(path?: string | Array<string>): any;
+    unwind(path?: string | Array<string>): any;
+    pick(...names?: string[]): /*elided*/ any;
+    omit(...names?: string[]): /*elided*/ any;
+    require(...fields: string[]): /*elided*/ any;
+    export(): any;
+    append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
+    format(name: any, fn: any): /*elided*/ any;
+    toString(): any;
+    assertions: any[];
+    meta: {};
+    required(): /*elided*/ any;
+    default(arg: any): /*elided*/ any;
+    custom(fn: Function): /*elided*/ any;
+    missing(fn: Function): /*elided*/ any;
+    strip(strip: any): /*elided*/ any;
+    allow(...set: any[]): /*elided*/ any;
+    reject(...set: any[]): /*elided*/ any;
+    nullable(): /*elided*/ any;
+    message(message: any): /*elided*/ any;
+    tag(tags: any): /*elided*/ any;
+    description(description: any): /*elided*/ any;
+    options(options: any): /*elided*/ any;
+    validate(value: any, options?: {}): Promise<any>;
+    clone(meta: any): /*elided*/ any;
+    toOpenApi(extra: any): any;
+    getAnyType(): {
+        type: string[];
+    };
+    getDefault(): {
+        default?: undefined;
+    } | {
+        default: any;
+    };
+    getNullable(): {
+        nullable: boolean;
+    };
+    expandExtra(extra?: {}): {};
+    inspect(): string;
+    assertEnum(set: any, allow: any): /*elided*/ any;
+    assert(type: any, fn: any): /*elided*/ any;
+    pushAssertion(assertion: any): void;
+    canSkipAssertion(value: any, assertion: any, options: any): any;
+    transform(fn: any): /*elided*/ any;
+    getSortIndex(type: any): number;
+    runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
+    enumToOpenApi(): any;
+};
+export const DATE_RANGE_SCHEMA: {
+    setup(): void;
+    get(path?: string | Array<string>): any;
+    unwind(path?: string | Array<string>): any;
+    pick(...names?: string[]): /*elided*/ any;
+    omit(...names?: string[]): /*elided*/ any;
+    require(...fields: string[]): /*elided*/ any;
+    export(): any;
+    append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
+    format(name: any, fn: any): /*elided*/ any;
+    toString(): any;
+    assertions: any[];
+    meta: {};
+    required(): /*elided*/ any;
+    default(arg: any): /*elided*/ any;
+    custom(fn: Function): /*elided*/ any;
+    missing(fn: Function): /*elided*/ any;
+    strip(strip: any): /*elided*/ any;
+    allow(...set: any[]): /*elided*/ any;
+    reject(...set: any[]): /*elided*/ any;
+    nullable(): /*elided*/ any;
+    message(message: any): /*elided*/ any;
+    tag(tags: any): /*elided*/ any;
+    description(description: any): /*elided*/ any;
+    options(options: any): /*elided*/ any;
+    validate(value: any, options?: {}): Promise<any>;
+    clone(meta: any): /*elided*/ any;
+    toOpenApi(extra: any): any;
+    getAnyType(): {
+        type: string[];
+    };
+    getDefault(): {
+        default?: undefined;
+    } | {
+        default: any;
+    };
+    getNullable(): {
+        nullable: boolean;
+    };
+    expandExtra(extra?: {}): {};
+    inspect(): string;
+    assertEnum(set: any, allow: any): /*elided*/ any;
+    assert(type: any, fn: any): /*elided*/ any;
+    pushAssertion(assertion: any): void;
+    canSkipAssertion(value: any, assertion: any, options: any): any;
+    transform(fn: any): /*elided*/ any;
+    getSortIndex(type: any): number;
+    runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
+    enumToOpenApi(): any;
+};
+export const REFERENCE_SCHEMA: import("@bedrockio/yada/types/Schema").default;
+//# sourceMappingURL=validation-schemas.d.ts.map

package/types/validation-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-schemas.d.ts","sourceRoot":"","sources":["../src/validation-schemas.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAoEI,CAAA;;;;;;;;;;;;;;;;;;EApEsD;AAE1D;;;;;;;;;;;;;;;;eAyBwB,CAAC;;;;;;;;;;;;iBAuBjB,CAAA;kBAA4B,CAAC;kBAEjC,CAAF;oBAEI,CAAC;oBAEI,CAAC;;;wBA2BC,CAAC;8BAGI,CAAC;oBAA+B,CAAC;oBAE1C,CAAC;oCAEL,CAAC;uBAAkC,CAAC;8BAAyC,CAAC;uBACzD,CAAC;iBAA4B,CAAC;;;mBAG0V,CAAC;yBAAoC,CAAC;0BAAqC,CAAC;yBAAoC,CAAC;sBAAiC,CAAC;yBAAoC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA1BtkB,CAAA;;;;;;;;;;;;;;;;;;EA1DC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAwDI,CAAA;;;;;;;;;;;;;;;;;EA9CC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA4CI,CAAA;;;;;;;;;;;;;;;;;EAlCC;AAEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAgCI,CAAA;;;;;;;;;;;;;;;;;EAEC;AAEL,8EAqBK"}

package/types/validation.d.ts

@@ -9,104 +9,4 @@ export function getTupleValidator(types: any): {
     (val: any): Promise<void>;
     schema: any;
 };
-export const OBJECT_ID_SCHEMA: {
-    required(): /*elided*/ any;
-    length(length: number): /*elided*/ any;
-    min(length: number): /*elided*/ any;
-    max(length: number): /*elided*/ any;
-    trim(): /*elided*/ any;
-    lowercase(assert?: boolean): /*elided*/ any;
-    uppercase(assert?: boolean): /*elided*/ any;
-    match(reg: RegExp): /*elided*/ any;
-    email(): /*elided*/ any;
-    phone(code: any): /*elided*/ any;
-    hex(): /*elided*/ any;
-    md5(): /*elided*/ any;
-    sha1(): /*elided*/ any;
-    ascii(): /*elided*/ any;
-    base64(options?: {
-        urlSafe?: boolean;
-    }): /*elided*/ any;
-    creditCard(): /*elided*/ any;
-    ip(): /*elided*/ any;
-    country(): /*elided*/ any;
-    locale(): /*elided*/ any;
-    jwt(): /*elided*/ any;
-    slug(): /*elided*/ any;
-    latlng(): /*elided*/ any;
-    postalCode(locale?: string): /*elided*/ any;
-    zipcode(): /*elided*/ any;
-    password(options?: {
-        minLength?: number;
-        minNumbers?: number;
-        minSymbols?: number;
-        minLowercase?: number;
-        minUppercase?: number;
-    }): /*elided*/ any;
-    url(options?: {
-        require_protocol?: boolean;
-        require_valid_protocol?: boolean;
-        require_host?: boolean;
-        require_port?: boolean;
-        allow_protocol_relative_urls?: boolean;
-        allow_fragments?: boolean;
-        allow_query_components?: boolean;
-        validate_length?: boolean;
-        protocols?: string[];
-    }): /*elided*/ any;
-    domain(options?: {
-        require_tld?: boolean;
-        allow_underscores?: boolean;
-        allow_trailing_dot?: boolean;
-        allow_numeric_tld?: boolean;
-        allow_wildcard?: boolean;
-        ignore_max_length?: boolean;
-    }): /*elided*/ any;
-    uuid(version?: 1 | 2 | 3 | 4 | 5): /*elided*/ any;
-    btc(): /*elided*/ any;
-    eth(): /*elided*/ any;
-    swift(): /*elided*/ any;
-    mongo(): /*elided*/ any;
-    format(name: any, fn: any): /*elided*/ any;
-    toString(): any;
-    assertions: any[];
-    meta: {};
-    default(arg: any): /*elided*/ any;
-    custom(fn: Function): /*elided*/ any;
-    missing(fn: Function): /*elided*/ any;
-    strip(strip: any): /*elided*/ any;
-    allow(...set: any[]): /*elided*/ any;
-    reject(...set: any[]): /*elided*/ any;
-    nullable(): /*elided*/ any;
-    message(message: any): /*elided*/ any;
-    tag(tags: any): /*elided*/ any;
-    description(description: any): /*elided*/ any;
-    options(options: any): /*elided*/ any;
-    validate(value: any, options?: {}): Promise<any>;
-    clone(meta: any): /*elided*/ any;
-    append(schema: any): import("@bedrockio/yada/types/Schema").default;
-    toOpenApi(extra: any): any;
-    getAnyType(): {
-        type: string[];
-    };
-    getDefault(): {
-        default?: undefined;
-    } | {
-        default: any;
-    };
-    getNullable(): {
-        nullable: boolean;
-    };
-    expandExtra(extra?: {}): {};
-    inspect(): string;
-    get(): void;
-    assertEnum(set: any, allow: any): /*elided*/ any;
-    assert(type: any, fn: any): /*elided*/ any;
-    pushAssertion(assertion: any): void;
-    canSkipAssertion(value: any, assertion: any, options: any): any;
-    transform(fn: any): /*elided*/ any;
-    getSortIndex(type: any): number;
-    runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
-    enumToOpenApi(): any;
-};
 //# sourceMappingURL=validation.d.ts.map

package/types/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAoFA,kDAEC;AAED,oEAkFC;AAsBD,wEAoBC;AAgWD;;;EAEC;AAED;;;EAOC;AA7iBD;;;;;;;;;;;;;;;;eAwBQ,CAAC;;;;;;;;;;;;iBAcmC,CAAC;kBAC3B,CAAC;kBAEH,CAAC;oBACA,CAAC;oBACF,CAAC;;;wBAmBZ,CAAC;8BACe,CAAC;oBAGD,CAAC;oBACV,CAAC;oCAGG,CAAC;uBAAmC,CAAA;8BAE9B,CAAC;uBACO,CAAC;iBACrB,CAAC;;;mBAkBL,CAAL;yBAAoC,CAAC;0BACpB,CAAC;yBACT,CAAC;sBAEH,CAAN;yBACc,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA9CQ,CAAC;;;;;;;;;;;;;;;;;;EA3CrB"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAqDA,kDAEC;AAED,oEAkFC;AAsBD,wEAoBC;AA8SD;;;EAEC;AAED;;;EAOC"}