@bedrockio/model 0.18.3 → 0.18.5

package/.prettierignore

@@ -0,0 +1 @@
+README.md

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 0.18.5
+
+- Moved warnings to `process.emitWarning`.
+- Fixed reload issue with mixed array types.
+
+## 0.18.4
+
+- Bumped yada to fix JSON schema issues.
+- Fixed `deletedRefs` being exposed.
+
 ## 0.18.3
 
 - Fixed issues with `getUpdateValidation` not allowing null for nested objects.

package/README.md

@@ -461,7 +461,8 @@ validation which will:
   `Model.getUpdateValidation` to allow this constraint to trickle down to the
   API.
 
-> [!WARNING] Note that calling `Model.updateOne` will throw an error when a
+> [!WARNING]
+> Note that calling `Model.updateOne` will throw an error when a
 > unique field exists on any document **including the document being updated**.
 > This is an intentional constraint that allows `updateOne` better peformance by
 > not having to fetch the ids of the documents being updated in order to exclude
@@ -1066,7 +1067,8 @@ await Product.findById(id).include('shop.user.^name').
 }
 ```
 
-> [!WARNING] Fields that are dynamically referenced using `refPath` are unable
+> [!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.
 
@@ -1613,7 +1615,8 @@ for (let shop of shops) {
 }
 ```
 
-> [!WARNING] The ability to run an `$and` query with multiple paths is currently
+> [!WARNING]
+> The ability to run an `$and` query with multiple paths is currently
 > not implemented.
 
 #### Erroring on Delete
@@ -1643,7 +1646,8 @@ Models that have delete hooks defined on them will keep a reference of the
 documents that were deleted. Calling `.restore()` on the document will also
 restore these references.
 
-> [!WARNING] Delete hooks are **only** run on a single document (`.delete` or
+> [!WARNING]
+> Delete hooks are **only** run on a single document (`.delete` or
 > `.restore`). They will not be run when using model methods like `deleteOne` or
 > `deleteMany`.
 

package/dist/cjs/delete-hooks.js

@@ -20,10 +20,15 @@ function addDeletedFields(definition) {
   if (!deleteHooks) {
     return;
   }
-  definition.attributes['deletedRefs'] = [{
-    _id: 'ObjectId',
-    ref: 'String'
-  }];
+  definition.attributes['deletedRefs'] = {
+    type: 'Array',
+    readAccess: 'none',
+    writeAccess: 'none',
+    attributes: {
+      _id: 'ObjectId',
+      ref: 'String'
+    }
+  };
 }
 function applyDeleteHooks(schema, definition) {
   let {

package/dist/cjs/utils.js

@@ -142,7 +142,15 @@ function getInnerField(obj, path) {
 }
 function resolveInnerField(field) {
   if (Array.isArray(field?.type)) {
-    field = field.type[0];
+    // An unspecified array type has no inner
+    // fields so return Array as the type.
+    if (field.type.length === 0) {
+      return {
+        type: 'Array'
+      };
+    } else {
+      field = field.type[0];
+    }
   }
   if (field?.type instanceof _mongoose.default.Schema) {
     field = field.type.obj;

package/dist/cjs/validation.js

@@ -368,13 +368,13 @@ function getSchemaForType(type, options) {
 }
 function getSearchSchema(schema, type) {
   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.');
+    return _yada.default.allow(schema, _yada.default.array(schema.nullable(false)), _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.');
+    return _yada.default.allow(schema, _yada.default.array(schema.nullable(false)), _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), _validationSchemas.DATE_RANGE_SCHEMA).description('Allows searching by a date, array of dates, or a range.');
+    return _yada.default.allow(schema, _yada.default.array(schema.nullable(false)), _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));
+    return _yada.default.allow(schema, _yada.default.array(schema.nullable(false)));
   } else {
     return schema;
   }

package/dist/cjs/warn.js

@@ -4,10 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = warn;
-var _logger = _interopRequireDefault(require("@bedrockio/logger"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function warn(...lines) {
   if (process.env.ENV_NAME !== 'test') {
-    _logger.default.warn(lines.join('\n'));
+    // Allow warnings to be traced.
+    process.emitWarning(lines.join('\n'));
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.18.3",
+  "version": "0.18.5",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {
@@ -39,7 +39,7 @@
     "@babel/preset-env": "^7.26.0",
     "@bedrockio/eslint-plugin": "^1.2.2",
     "@bedrockio/prettier-config": "^1.1.1",
-    "@bedrockio/yada": "^1.9.0",
+    "@bedrockio/yada": "^1.10.0",
     "@shelf/jest-mongodb": "^5.2.2",
     "eslint": "^9.36.0",
     "jest": "^30.2.0",

package/src/delete-hooks.js

@@ -13,12 +13,15 @@ export function addDeletedFields(definition) {
     return;
   }
 
-  definition.attributes['deletedRefs'] = [
-    {
+  definition.attributes['deletedRefs'] = {
+    type: 'Array',
+    readAccess: 'none',
+    writeAccess: 'none',
+    attributes: {
       _id: 'ObjectId',
       ref: 'String',
     },
-  ];
+  };
 }
 
 export function applyDeleteHooks(schema, definition) {

package/src/utils.js

@@ -130,7 +130,15 @@ export function getInnerField(obj, path) {
 
 function resolveInnerField(field) {
   if (Array.isArray(field?.type)) {
-    field = field.type[0];
+    // An unspecified array type has no inner
+    // fields so return Array as the type.
+    if (field.type.length === 0) {
+      return {
+        type: 'Array',
+      };
+    } else {
+      field = field.type[0];
+    }
   }
   if (field?.type instanceof mongoose.Schema) {
     field = field.type.obj;

package/src/validation.js

@@ -270,6 +270,7 @@ function getArraySchema(arr, options) {
   } else {
     throw new Error('Array schema may not have more than 1 element.');
   }
+
   return schema;
 }
 
@@ -397,22 +398,22 @@ function getSchemaForType(type, options) {
 function getSearchSchema(schema, type) {
   if (type === 'String') {
     return yd
-      .allow(schema, yd.array(schema), STRING_RANGE_SCHEMA)
+      .allow(schema, yd.array(schema.nullable(false)), 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), NUMBER_RANGE_SCHEMA)
+      .allow(schema, yd.array(schema.nullable(false)), NUMBER_RANGE_SCHEMA)
       .description(
         'Allows searching by a value, array of values, or a  range.',
       );
   } else if (type === 'Date') {
     return yd
-      .allow(schema, yd.array(schema), DATE_RANGE_SCHEMA)
+      .allow(schema, yd.array(schema.nullable(false)), DATE_RANGE_SCHEMA)
       .description('Allows searching by a date, array of dates, or a range.');
   } else if (type === 'ObjectId') {
-    return yd.allow(schema, yd.array(schema));
+    return yd.allow(schema, yd.array(schema.nullable(false)));
   } else {
     return schema;
   }

package/src/warn.js

@@ -1,7 +1,6 @@
-import logger from '@bedrockio/logger';
-
 export default function warn(...lines) {
   if (process.env.ENV_NAME !== 'test') {
-    logger.warn(lines.join('\n'));
+    // Allow warnings to be traced.
+    process.emitWarning(lines.join('\n'));
   }
 }

package/types/delete-hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delete-hooks.d.ts","sourceRoot":"","sources":["../src/delete-hooks.js"],"names":[],"mappings":"AAQA,wDAaC;AAED,qEAqCC"}
+{"version":3,"file":"delete-hooks.d.ts","sourceRoot":"","sources":["../src/delete-hooks.js"],"names":[],"mappings":"AAQA,wDAgBC;AAED,qEAqCC"}

package/types/schema.d.ts

@@ -28,9 +28,7 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     id?: boolean;
     _id?: boolean;
     minimize?: boolean;
-    optimisticConcurrency?: boolean | string[] | {
-        exclude: string[];
-    };
+    optimisticConcurrency?: boolean;
     pluginTags?: string[];
     read?: string;
     readConcern?: {
@@ -49,16 +47,16 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
         getters: boolean;
         versionKey: boolean;
         transform: (doc: any, ret: any, options: any) => void;
-    } | mongoose.ToObjectOptions<any, any>;
+    } | mongoose.ToObjectOptions<any>;
     toObject: {
         getters: boolean;
         versionKey: boolean;
         transform: (doc: any, ret: any, options: any) => void;
-    } | mongoose.ToObjectOptions<any, any>;
+    } | mongoose.ToObjectOptions<any>;
     typeKey?: string;
     validateBeforeSave?: boolean;
     validateModifiedOnly?: boolean;
-    versionKey?: string | false;
+    versionKey?: string | boolean;
     selectPopulatedPaths?: boolean;
     skipVersioning?: {
         [key: string]: boolean;
@@ -66,13 +64,12 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     storeSubdocValidationError?: boolean;
     timestamps: boolean | mongoose.SchemaTimestampsConfig;
     suppressReservedKeysWarning?: boolean;
-    statics?: mongoose.AddThisParameter<any, mongoose.Model<any, any, any, any, any, any>>;
+    statics?: mongoose.AddThisParameter<any, mongoose.Model<any, {}, {}, {}, any, any>>;
     methods?: mongoose.AddThisParameter<any, any> & mongoose.AnyObject;
     query?: any;
     castNonArrays?: boolean;
     virtuals?: mongoose.SchemaOptionsVirtualsPropertyType<any, any, any>;
     overwriteModels?: boolean;
-    encryptionType?: "csfle" | "queryableEncryption";
 }, any, any>;
 export function normalizeAttributes(arg: any, path?: any[]): any;
 import mongoose from 'mongoose';

package/types/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAyBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,QAAQ,CAAC,aAAa;;;;;;;YA2C7B,CAAC;WAAa,CAAC;mBACH,CAAC;;;;;;;;;;;;;;;;;;;;;;;SAgIb,CAAC;gBAA4B,CAAA;SAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA3H5C;AAED,iEAcC;qBA9FoB,UAAU"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAyBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,QAAQ,CAAC,aAAa;;;;;;;YAuC/B,CAAC;WAAa,CAAC;mBACF,CAAC;;;;;;;;;;;;;;;;;;;;;SAsHkC,CAAC;gBACzC,CAAA;SAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA9GrB;AAED,iEAcC;qBA9FoB,UAAU"}

package/types/search.d.ts

@@ -7,7 +7,7 @@ export function searchValidation(options?: {}): {
     omit(...names?: string[]): /*elided*/ any;
     require(...fields: string[]): /*elided*/ any;
     requireAll(): /*elided*/ any;
-    requireAllWithin(): /*elided*/ any;
+    transform(fn: Function, root?: boolean): /*elided*/ any;
     export(): any;
     append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
     options(options?: {
@@ -16,30 +16,30 @@ export function searchValidation(options?: {}): {
         allowFlatKeys?: boolean;
         expandFlatKeys?: boolean;
     }): /*elided*/ any;
+    toJsonSchema(options: any): any;
     format(name: any, fn: any): /*elided*/ any;
     toString(): any;
     assertions: any[];
     meta: {};
-    required(): /*elided*/ any;
+    required(allow?: boolean): /*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;
+    nullable(allow?: boolean): /*elided*/ any;
     message(message: any): /*elided*/ any;
     tag(tags: any): /*elided*/ any;
     description(description: any): /*elided*/ any;
     validate(value: any, options?: {}): Promise<any>;
     clone(meta: any): /*elided*/ any;
-    toJsonSchema(extra?: any): any;
-    toOpenApi(...extra: any[]): any;
+    toOpenApi(options: any): any;
     toJSON(): any;
-    getAnyType(): {
-        type: string[];
+    getType(): {
+        type: any;
     };
-    getFormat(): {
+    getFormat(options: any): {
         format: any;
     };
     getDefault(): {
@@ -47,23 +47,19 @@ export function searchValidation(options?: {}): {
     } | {
         default: any;
     };
-    getNullable(): {
-        nullable: boolean;
-    };
-    getEnum(): any;
-    expandExtra(extra?: {}): {};
+    getEnum(options: any): any;
+    getTags(options?: {}): any;
     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;
+    transformValue(fn: any): /*elided*/ any;
     getSortIndex(type: any): number;
     runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
 };
 export function exportValidation(options?: {}): {
     filename: {
-        required(): /*elided*/ any;
         length(length: number): /*elided*/ any;
         min(length: number): /*elided*/ any;
         max(length: number): /*elided*/ any;
@@ -123,16 +119,18 @@ export function exportValidation(options?: {}): {
         calendar(): /*elided*/ any;
         time(): /*elided*/ any;
         format(name: any, fn: any): /*elided*/ any;
+        toJsonSchema(options: any): any;
         toString(): any;
         assertions: any[];
         meta: {};
+        required(allow?: boolean): /*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;
+        nullable(allow?: boolean): /*elided*/ any;
         message(message: any): /*elided*/ any;
         tag(tags: any): /*elided*/ any;
         description(description: any): /*elided*/ any;
@@ -140,13 +138,12 @@ export function exportValidation(options?: {}): {
         validate(value: any, options?: {}): Promise<any>;
         clone(meta: any): /*elided*/ any;
         append(schema: any): import("@bedrockio/yada/types/Schema").default;
-        toJsonSchema(extra?: any): any;
-        toOpenApi(...extra: any[]): any;
+        toOpenApi(options: any): any;
         toJSON(): any;
-        getAnyType(): {
-            type: string[];
+        getType(): {
+            type: any;
         };
-        getFormat(): {
+        getFormat(options: any): {
             format: any;
         };
         getDefault(): {
@@ -154,24 +151,20 @@ export function exportValidation(options?: {}): {
         } | {
             default: any;
         };
-        getNullable(): {
-            nullable: boolean;
-        };
-        getEnum(): any;
-        requireAllWithin(): /*elided*/ any;
-        expandExtra(extra?: {}): {};
+        getEnum(options: any): any;
+        getTags(options?: {}): any;
+        transform(fn: Function, root: any): /*elided*/ any;
         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;
+        transformValue(fn: any): /*elided*/ any;
         getSortIndex(type: any): number;
         runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
     };
     format: {
-        required(): /*elided*/ any;
         length(length: number): /*elided*/ any;
         min(length: number): /*elided*/ any;
         max(length: number): /*elided*/ any;
@@ -231,16 +224,18 @@ export function exportValidation(options?: {}): {
         calendar(): /*elided*/ any;
         time(): /*elided*/ any;
         format(name: any, fn: any): /*elided*/ any;
+        toJsonSchema(options: any): any;
         toString(): any;
         assertions: any[];
         meta: {};
+        required(allow?: boolean): /*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;
+        nullable(allow?: boolean): /*elided*/ any;
         message(message: any): /*elided*/ any;
         tag(tags: any): /*elided*/ any;
         description(description: any): /*elided*/ any;
@@ -248,13 +243,12 @@ export function exportValidation(options?: {}): {
         validate(value: any, options?: {}): Promise<any>;
         clone(meta: any): /*elided*/ any;
         append(schema: any): import("@bedrockio/yada/types/Schema").default;
-        toJsonSchema(extra?: any): any;
-        toOpenApi(...extra: any[]): any;
+        toOpenApi(options: any): any;
         toJSON(): any;
-        getAnyType(): {
-            type: string[];
+        getType(): {
+            type: any;
         };
-        getFormat(): {
+        getFormat(options: any): {
             format: any;
         };
         getDefault(): {
@@ -262,19 +256,16 @@ export function exportValidation(options?: {}): {
         } | {
             default: any;
         };
-        getNullable(): {
-            nullable: boolean;
-        };
-        getEnum(): any;
-        requireAllWithin(): /*elided*/ any;
-        expandExtra(extra?: {}): {};
+        getEnum(options: any): any;
+        getTags(options?: {}): any;
+        transform(fn: Function, root: any): /*elided*/ any;
         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;
+        transformValue(fn: any): /*elided*/ any;
         getSortIndex(type: any): number;
         runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
     };

package/types/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAuBA,gEAaC;AAED;;;;;;;;;;;;kBA8GU,CAAH;oBAEG,CAAR;qBAEU,CAAF;sBAEF,CAAJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAlDwB,CAAC;;;;;;;;;;;;;;;;;EAzC5B;AAED;;;;;;;;;;;;;;;;;mBAtBI,CAAA;;;;;;;;;;;;qBAuBC,CAAC;sBAA4B,CAAC;sBACvB,CAAC;wBAA8B,CAAC;wBAEnC,CAAC;;;4BA4BN,CAAD;kCAAyC,CAAC;wBACtC,CAAC;wBAA+B,CAAC;wCAKlC,CAAA;2BAAkC,CAAC;kCACP,CAAC;2BAIhB,CAAC;qBAA4B,CAAC;;;uBAuB/C,CAAA;6BAEA,CAAA;8BAEK,CAAC;6BAAoC,CAAC;0BAClB,CAAC;6BAIjB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBApCgB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA7DzB,CAAA;;;;;;;;;;;;qBAuBC,CAAC;sBAA4B,CAAC;sBACvB,CAAC;wBAA8B,CAAC;wBAEnC,CAAC;;;4BA4BN,CAAD;kCAAyC,CAAC;wBACtC,CAAC;wBAA+B,CAAC;wCAKlC,CAAA;2BAAkC,CAAC;kCACP,CAAC;2BAIhB,CAAC;qBAA4B,CAAC;;;uBAuB/C,CAAA;6BAEA,CAAA;8BAEK,CAAC;6BAAoC,CAAC;0BAClB,CAAC;6BAIjB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBApCgB,CAAC;;;;;;;;;;;;;;;;;;;;EA1B5B"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAuBA,gEAaC;AAED;;;;;;;;;;;;kBAmHU,CAAC;oBAGD,CAAP;qBACoB,CAAC;sBAGlB,CAAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA7B6B,CAAC;;;;;;;;;;;;;;EApElC;AAED;;;;;;;;;;;;;;;;mBA1BmD,CAAC;;;;;;;;;;;;qBAuBlD,CAAC;sBAGmB,CAAC;sBACrB,CAAC;wBAA8B,CAAC;wBACrB,CAAC;;;4BAwBc,CAAC;kCAK3B,CAAD;wBACc,CAAC;wBAA+B,CAAC;wCACtB,CAAC;2BAGhB,CAAC;kCAES,CAAC;2BACd,CAAC;qBACL,CAAJ;;;uBAuBgC,CAAC;6BAEjB,CAAC;8BACF,CAAC;6BAGZ,CAAH;0BACgB,CAAC;6BACZ,CAAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAL8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA5FgB,CAAC;;;;;;;;;;;;qBAuBlD,CAAC;sBAGmB,CAAC;sBACrB,CAAC;wBAA8B,CAAC;wBACrB,CAAC;;;4BAwBc,CAAC;kCAK3B,CAAD;wBACc,CAAC;wBAA+B,CAAC;wCACtB,CAAC;2BAGhB,CAAC;kCAES,CAAC;2BACd,CAAC;qBACL,CAAJ;;;uBAuBgC,CAAC;6BAEjB,CAAC;8BACF,CAAC;6BAGZ,CAAH;0BACgB,CAAC;6BACZ,CAAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAL8B,CAAC;;;;;;;;;;;;;;;;;EArDlC"}

package/types/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAQA,iDAcC;AAED,gHAEC;AAED,+DAEC;AAED,0DAEC;AAED,4DAEC;AAED,4DAEC;AAED,2DAGC;AAOD,mDAGC;AAuBD,mDAgBC;AAKD;;;;EAoBC;AAKD,wDAEC;AAcD,iDAYC;qBA1JoB,UAAU"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.js"],"names":[],"mappings":"AAQA,iDAcC;AAED,gHAEC;AAED,+DAEC;AAED,0DAEC;AAED,4DAEC;AAED,4DAEC;AAED,2DAGC;AAOD,mDAGC;AAuBD,mDAgBC;AAKD;;;;EAoBC;AAKD,wDAEC;AAsBD,iDAYC;qBAlKoB,UAAU"}

package/types/validation-schemas.d.ts

@@ -10,14 +10,14 @@ export const DATE_SCHEMA: {
     unix(): /*elided*/ any;
     assertions: any[];
     meta: {};
-    required(): /*elided*/ any;
+    required(allow?: boolean): /*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;
+    nullable(allow?: boolean): /*elided*/ any;
     message(message: any): /*elided*/ any;
     tag(tags: any): /*elided*/ any;
     description(description: any): /*elided*/ any;
@@ -25,13 +25,17 @@ export const DATE_SCHEMA: {
     validate(value: any, options?: {}): Promise<any>;
     clone(meta: any): /*elided*/ any;
     append(schema: any): import("@bedrockio/yada/types/Schema").default;
-    toJsonSchema(extra?: any): any;
-    toOpenApi(...extra: any[]): any;
+    toJsonSchema(options?: {
+        tag?: Function;
+        style?: "openai";
+        stripExtensions?: boolean;
+    }): any;
+    toOpenApi(options: any): any;
     toJSON(): any;
-    getAnyType(): {
-        type: string[];
+    getType(): {
+        type: any;
     };
-    getFormat(): {
+    getFormat(options: any): {
         format: any;
     };
     getDefault(): {
@@ -39,24 +43,20 @@ export const DATE_SCHEMA: {
     } | {
         default: any;
     };
-    getNullable(): {
-        nullable: boolean;
-    };
-    getEnum(): any;
-    requireAllWithin(): /*elided*/ any;
-    expandExtra(extra?: {}): {};
+    getEnum(options: any): any;
+    getTags(options?: {}): any;
+    transform(fn: Function, root: any): /*elided*/ any;
     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;
+    transformValue(fn: any): /*elided*/ any;
     getSortIndex(type: any): number;
     runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
 };
 export const OBJECT_ID_SCHEMA: {
-    required(): /*elided*/ any;
     length(length: number): /*elided*/ any;
     min(length: number): /*elided*/ any;
     max(length: number): /*elided*/ any;
@@ -116,16 +116,18 @@ export const OBJECT_ID_SCHEMA: {
     calendar(): /*elided*/ any;
     time(): /*elided*/ any;
     format(name: any, fn: any): /*elided*/ any;
+    toJsonSchema(options: any): any;
     toString(): any;
     assertions: any[];
     meta: {};
+    required(allow?: boolean): /*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;
+    nullable(allow?: boolean): /*elided*/ any;
     message(message: any): /*elided*/ any;
     tag(tags: any): /*elided*/ any;
     description(description: any): /*elided*/ any;
@@ -133,13 +135,12 @@ export const OBJECT_ID_SCHEMA: {
     validate(value: any, options?: {}): Promise<any>;
     clone(meta: any): /*elided*/ any;
     append(schema: any): import("@bedrockio/yada/types/Schema").default;
-    toJsonSchema(extra?: any): any;
-    toOpenApi(...extra: any[]): any;
+    toOpenApi(options: any): any;
     toJSON(): any;
-    getAnyType(): {
-        type: string[];
+    getType(): {
+        type: any;
     };
-    getFormat(): {
+    getFormat(options: any): {
         format: any;
     };
     getDefault(): {
@@ -147,19 +148,16 @@ export const OBJECT_ID_SCHEMA: {
     } | {
         default: any;
     };
-    getNullable(): {
-        nullable: boolean;
-    };
-    getEnum(): any;
-    requireAllWithin(): /*elided*/ any;
-    expandExtra(extra?: {}): {};
+    getEnum(options: any): any;
+    getTags(options?: {}): any;
+    transform(fn: Function, root: any): /*elided*/ any;
     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;
+    transformValue(fn: any): /*elided*/ any;
     getSortIndex(type: any): number;
     runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
 };
@@ -171,7 +169,7 @@ export const NUMBER_RANGE_SCHEMA: {
     omit(...names?: string[]): /*elided*/ any;
     require(...fields: string[]): /*elided*/ any;
     requireAll(): /*elided*/ any;
-    requireAllWithin(): /*elided*/ any;
+    transform(fn: Function, root?: boolean): /*elided*/ any;
     export(): any;
     append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
     options(options?: {
@@ -180,30 +178,30 @@ export const NUMBER_RANGE_SCHEMA: {
         allowFlatKeys?: boolean;
         expandFlatKeys?: boolean;
     }): /*elided*/ any;
+    toJsonSchema(options: any): any;
     format(name: any, fn: any): /*elided*/ any;
     toString(): any;
     assertions: any[];
     meta: {};
-    required(): /*elided*/ any;
+    required(allow?: boolean): /*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;
+    nullable(allow?: boolean): /*elided*/ any;
     message(message: any): /*elided*/ any;
     tag(tags: any): /*elided*/ any;
     description(description: any): /*elided*/ any;
     validate(value: any, options?: {}): Promise<any>;
     clone(meta: any): /*elided*/ any;
-    toJsonSchema(extra?: any): any;
-    toOpenApi(...extra: any[]): any;
+    toOpenApi(options: any): any;
     toJSON(): any;
-    getAnyType(): {
-        type: string[];
+    getType(): {
+        type: any;
     };
-    getFormat(): {
+    getFormat(options: any): {
         format: any;
     };
     getDefault(): {
@@ -211,17 +209,14 @@ export const NUMBER_RANGE_SCHEMA: {
     } | {
         default: any;
     };
-    getNullable(): {
-        nullable: boolean;
-    };
-    getEnum(): any;
-    expandExtra(extra?: {}): {};
+    getEnum(options: any): any;
+    getTags(options?: {}): any;
     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;
+    transformValue(fn: any): /*elided*/ any;
     getSortIndex(type: any): number;
     runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
 };
@@ -233,7 +228,7 @@ export const STRING_RANGE_SCHEMA: {
     omit(...names?: string[]): /*elided*/ any;
     require(...fields: string[]): /*elided*/ any;
     requireAll(): /*elided*/ any;
-    requireAllWithin(): /*elided*/ any;
+    transform(fn: Function, root?: boolean): /*elided*/ any;
     export(): any;
     append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
     options(options?: {
@@ -242,30 +237,30 @@ export const STRING_RANGE_SCHEMA: {
         allowFlatKeys?: boolean;
         expandFlatKeys?: boolean;
     }): /*elided*/ any;
+    toJsonSchema(options: any): any;
     format(name: any, fn: any): /*elided*/ any;
     toString(): any;
     assertions: any[];
     meta: {};
-    required(): /*elided*/ any;
+    required(allow?: boolean): /*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;
+    nullable(allow?: boolean): /*elided*/ any;
     message(message: any): /*elided*/ any;
     tag(tags: any): /*elided*/ any;
     description(description: any): /*elided*/ any;
     validate(value: any, options?: {}): Promise<any>;
     clone(meta: any): /*elided*/ any;
-    toJsonSchema(extra?: any): any;
-    toOpenApi(...extra: any[]): any;
+    toOpenApi(options: any): any;
     toJSON(): any;
-    getAnyType(): {
-        type: string[];
+    getType(): {
+        type: any;
     };
-    getFormat(): {
+    getFormat(options: any): {
         format: any;
     };
     getDefault(): {
@@ -273,17 +268,14 @@ export const STRING_RANGE_SCHEMA: {
     } | {
         default: any;
     };
-    getNullable(): {
-        nullable: boolean;
-    };
-    getEnum(): any;
-    expandExtra(extra?: {}): {};
+    getEnum(options: any): any;
+    getTags(options?: {}): any;
     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;
+    transformValue(fn: any): /*elided*/ any;
     getSortIndex(type: any): number;
     runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
 };
@@ -295,7 +287,7 @@ export const DATE_RANGE_SCHEMA: {
     omit(...names?: string[]): /*elided*/ any;
     require(...fields: string[]): /*elided*/ any;
     requireAll(): /*elided*/ any;
-    requireAllWithin(): /*elided*/ any;
+    transform(fn: Function, root?: boolean): /*elided*/ any;
     export(): any;
     append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
     options(options?: {
@@ -304,30 +296,30 @@ export const DATE_RANGE_SCHEMA: {
         allowFlatKeys?: boolean;
         expandFlatKeys?: boolean;
     }): /*elided*/ any;
+    toJsonSchema(options: any): any;
     format(name: any, fn: any): /*elided*/ any;
     toString(): any;
     assertions: any[];
     meta: {};
-    required(): /*elided*/ any;
+    required(allow?: boolean): /*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;
+    nullable(allow?: boolean): /*elided*/ any;
     message(message: any): /*elided*/ any;
     tag(tags: any): /*elided*/ any;
     description(description: any): /*elided*/ any;
     validate(value: any, options?: {}): Promise<any>;
     clone(meta: any): /*elided*/ any;
-    toJsonSchema(extra?: any): any;
-    toOpenApi(...extra: any[]): any;
+    toOpenApi(options: any): any;
     toJSON(): any;
-    getAnyType(): {
-        type: string[];
+    getType(): {
+        type: any;
     };
-    getFormat(): {
+    getFormat(options: any): {
         format: any;
     };
     getDefault(): {
@@ -335,17 +327,14 @@ export const DATE_RANGE_SCHEMA: {
     } | {
         default: any;
     };
-    getNullable(): {
-        nullable: boolean;
-    };
-    getEnum(): any;
-    expandExtra(extra?: {}): {};
+    getEnum(options: any): any;
+    getTags(options?: {}): any;
     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;
+    transformValue(fn: any): /*elided*/ any;
     getSortIndex(type: any): number;
     runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
 };
@@ -358,7 +347,7 @@ export const INCLUDE_FIELD_SCHEMA: {
     omit(...names?: string[]): /*elided*/ any;
     require(...fields: string[]): /*elided*/ any;
     requireAll(): /*elided*/ any;
-    requireAllWithin(): /*elided*/ any;
+    transform(fn: Function, root?: boolean): /*elided*/ any;
     export(): any;
     append(arg: import("@bedrockio/yada/types/object").SchemaMap | import("@bedrockio/yada/types/Schema").default): /*elided*/ any;
     options(options?: {
@@ -367,30 +356,30 @@ export const INCLUDE_FIELD_SCHEMA: {
         allowFlatKeys?: boolean;
         expandFlatKeys?: boolean;
     }): /*elided*/ any;
+    toJsonSchema(options: any): any;
     format(name: any, fn: any): /*elided*/ any;
     toString(): any;
     assertions: any[];
     meta: {};
-    required(): /*elided*/ any;
+    required(allow?: boolean): /*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;
+    nullable(allow?: boolean): /*elided*/ any;
     message(message: any): /*elided*/ any;
     tag(tags: any): /*elided*/ any;
     description(description: any): /*elided*/ any;
     validate(value: any, options?: {}): Promise<any>;
     clone(meta: any): /*elided*/ any;
-    toJsonSchema(extra?: any): any;
-    toOpenApi(...extra: any[]): any;
+    toOpenApi(options: any): any;
     toJSON(): any;
-    getAnyType(): {
-        type: string[];
+    getType(): {
+        type: any;
     };
-    getFormat(): {
+    getFormat(options: any): {
         format: any;
     };
     getDefault(): {
@@ -398,17 +387,14 @@ export const INCLUDE_FIELD_SCHEMA: {
     } | {
         default: any;
     };
-    getNullable(): {
-        nullable: boolean;
-    };
-    getEnum(): any;
-    expandExtra(extra?: {}): {};
+    getEnum(options: any): any;
+    getTags(options?: {}): any;
     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;
+    transformValue(fn: any): /*elided*/ any;
     getSortIndex(type: any): number;
     runAssertion(value: any, assertion: any, options?: {}): Promise<any>;
 };

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

@@ -1 +1 @@
-{"version":3,"file":"validation-schemas.d.ts","sourceRoot":"","sources":["../src/validation-schemas.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA0F4E,CAAC;;;;;;;;;;;;;;;;;;;EA1FnB;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;;;mBAW0D,CAAC;yBAAoC,CAAC;0BAAqC,CAAC;yBAAoC,CAAC;sBAAiC,CAAC;yBAAoC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAZ9N,CAAC;;;;;;;;;;;;;;;;;;;EAhFxE;AAEL;;;;;;;;;;;;kBA0Fmb,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAZ3c,CAAC;;;;;;;;;;;;;;;;;EApExE;AAEL;;;;;;;;;;;;kBA8Emb,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAZ3c,CAAC;;;;;;;;;;;;;;;;;EAxDxE;AAEL;;;;;;;;;;;;kBAkEmb,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAZ3c,CAAC;;;;;;;;;;;;;;;;;EApBxE;AAEL,8EAqBK;AAEL;;;;;;;;;;;;kBAOmb,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAZ3c,CAAC;;;;;;;;;;;;;;;;;EAW1E"}
+{"version":3,"file":"validation-schemas.d.ts","sourceRoot":"","sources":["../src/validation-schemas.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA2FwE,CAAC;aACjE,CAAC;uBAGc,CAAC;;;;;;;;;;;eAO2H,CAAC;;;;;;;;;;;;;;;;EAtG1F;AAE1D;;;;;;;;;;;;;;;eAwBwB,CAAC;;;;;;;;;;;;iBAoBjB,CAAC;kBAEC,CAAC;kBAEH,CAAH;oBAA8B,CAAC;oBAEhC,CAAD;;;wBA4BW,CAAC;8BAEK,CAAA;oBAEd,CAAF;oBAEiB,CAAC;oCACjB,CAAC;uBAEF,CAAD;8BACkB,CAAC;uBAAkC,CAAC;iBAA4B,CAAC;;;mBAYjC,CAAC;yBAAoC,CAAC;0BAAqC,CAAC;yBAAoC,CAAC;sBAAiC,CAAC;yBAAoC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAA1F,CAAC;;;;;;;;;;;;;;;;EA5F/I;AAEL;;;;;;;;;;;;kBA0FghB,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAAje,CAAC;;;;;;;;;;;;;;EAhF/I;AAEL;;;;;;;;;;;;kBA8EghB,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAAje,CAAC;;;;;;;;;;;;;;EApE/I;AAEL;;;;;;;;;;;;kBAkEghB,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAAje,CAAC;;;;;;;;;;;;;;EAhC/I;AAEL,8EAqBK;AAEL;;;;;;;;;;;;kBAOghB,CAAC;oBAA+B,CAAC;qBAAgC,CAAC;sBAAiC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAAje,CAAC;;;;;;;;;;;;;;EADjJ"}

package/types/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AA6DA,kDAEC;AAED,oEA4FC;AAsBD,wEAiBC;AAkUD;;;EAEC;AAED;;;EAOC"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AA6DA,kDAEC;AAED,oEA4FC;AAsBD,wEAiBC;AAmUD;;;EAEC;AAED;;;EAOC"}

package/types/warn.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"warn.d.ts","sourceRoot":"","sources":["../src/warn.js"],"names":[],"mappings":"AAEA,oDAIC"}
+{"version":3,"file":"warn.d.ts","sourceRoot":"","sources":["../src/warn.js"],"names":[],"mappings":"AAAA,oDAKC"}