@bedrockio/model 0.18.2 → 0.18.4

package/.prettierignore

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

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 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.
+
 ## 0.18.2
 
 - Further fix for `reload` not working with delete hooks.

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/validation.js

@@ -183,7 +183,7 @@ function getObjectSchema(arg, options) {
   if ((0, _utils.isSchemaTypedef)(arg)) {
     return getSchemaForTypedef(arg, options);
   } else if ((0, _utils.isMongooseSchema)(arg)) {
-    return getObjectSchema(arg.obj, options);
+    return getNestedSchema(arg.obj, options);
   } else if (Array.isArray(arg)) {
     return getArraySchema(arg, options);
   } else if (typeof arg === 'object') {
@@ -195,7 +195,7 @@ function getObjectSchema(arg, options) {
     const map = {};
     for (let [key, field] of Object.entries(arg)) {
       if (!isExcludedField(field, options)) {
-        map[key] = getObjectSchema(field, options);
+        map[key] = getNestedSchema(field, options);
       }
     }
     let schema = _yada.default.object(map);
@@ -214,11 +214,21 @@ function getObjectSchema(arg, options) {
         allowFlatKeys: true
       });
     }
+    if (isNullAllowed(options)) {
+      schema = schema.nullable();
+    }
     return schema;
   } else {
     return getSchemaForType(arg, options);
   }
 }
+function getNestedSchema(arg, options) {
+  return getObjectSchema(arg, {
+    ...options,
+    isNested: true,
+    isArrayElement: false
+  });
+}
 function getArraySchema(arr, options) {
   let schema;
   if (arr.length === 0) {
@@ -228,7 +238,8 @@ function getArraySchema(arr, options) {
     // validations as they are a new context.
     schema = getObjectSchema(arr[0], {
       ...options,
-      skipRequired: false
+      skipRequired: false,
+      isArrayElement: true
     });
     if (!options.unwindArrayFields) {
       schema = _yada.default.array(schema);
@@ -255,7 +266,7 @@ function getSchemaForTypedef(typedef, options = {}) {
     // Null may be allowed to unset non-required fields
     // in an update operation or to search for non-existent
     // fields in a search operation.
-    if (allowNull(typedef, options)) {
+    if (isNullAllowedForTypedef(typedef, options)) {
       schema = schema.nullable();
     }
 
@@ -357,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;
   }
@@ -371,8 +382,16 @@ function getSearchSchema(schema, type) {
 function isRequired(typedef, options) {
   return typedef.required && !typedef.default && !options.skipRequired;
 }
-function allowNull(typedef, options) {
-  if (!options.allowNull) {
+function isNullAllowed(options) {
+  const {
+    allowNull,
+    isNested,
+    isArrayElement
+  } = options;
+  return allowNull && isNested && !isArrayElement;
+}
+function isNullAllowedForTypedef(typedef, options) {
+  if (!isNullAllowed(options)) {
     return false;
   }
   const {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.18.2",
+  "version": "0.18.4",
   "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/validation.js

@@ -200,15 +200,17 @@ function getObjectSchema(arg, options) {
   if (isSchemaTypedef(arg)) {
     return getSchemaForTypedef(arg, options);
   } else if (isMongooseSchema(arg)) {
-    return getObjectSchema(arg.obj, options);
+    return getNestedSchema(arg.obj, options);
   } else if (Array.isArray(arg)) {
     return getArraySchema(arg, options);
   } else if (typeof arg === 'object') {
     const { stripUnknown, stripEmpty, allowFlatKeys } = options;
+
     const map = {};
+
     for (let [key, field] of Object.entries(arg)) {
       if (!isExcludedField(field, options)) {
-        map[key] = getObjectSchema(field, options);
+        map[key] = getNestedSchema(field, options);
       }
     }
 
@@ -232,12 +234,24 @@ function getObjectSchema(arg, options) {
       });
     }
 
+    if (isNullAllowed(options)) {
+      schema = schema.nullable();
+    }
+
     return schema;
   } else {
     return getSchemaForType(arg, options);
   }
 }
 
+function getNestedSchema(arg, options) {
+  return getObjectSchema(arg, {
+    ...options,
+    isNested: true,
+    isArrayElement: false,
+  });
+}
+
 function getArraySchema(arr, options) {
   let schema;
   if (arr.length === 0) {
@@ -248,6 +262,7 @@ function getArraySchema(arr, options) {
     schema = getObjectSchema(arr[0], {
       ...options,
       skipRequired: false,
+      isArrayElement: true,
     });
     if (!options.unwindArrayFields) {
       schema = yd.array(schema);
@@ -255,6 +270,7 @@ function getArraySchema(arr, options) {
   } else {
     throw new Error('Array schema may not have more than 1 element.');
   }
+
   return schema;
 }
 
@@ -275,7 +291,7 @@ function getSchemaForTypedef(typedef, options = {}) {
     // Null may be allowed to unset non-required fields
     // in an update operation or to search for non-existent
     // fields in a search operation.
-    if (allowNull(typedef, options)) {
+    if (isNullAllowedForTypedef(typedef, options)) {
       schema = schema.nullable();
     }
 
@@ -382,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;
   }
@@ -407,8 +423,13 @@ function isRequired(typedef, options) {
   return typedef.required && !typedef.default && !options.skipRequired;
 }
 
-function allowNull(typedef, options) {
-  if (!options.allowNull) {
+function isNullAllowed(options) {
+  const { allowNull, isNested, isArrayElement } = options;
+  return allowNull && isNested && !isArrayElement;
+}
+
+function isNullAllowedForTypedef(typedef, options) {
+  if (!isNullAllowed(options)) {
     return false;
   }
   const { required, type } = typedef;

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

@@ -19,6 +19,7 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     };
     collation?: mongoose.mongo.CollationOptions;
     collectionOptions?: mongoose.mongo.CreateCollectionOptions;
+    lean?: boolean | mongoose.LeanOptions;
     timeseries?: mongoose.mongo.TimeSeriesCollectionOptions;
     expireAfterSeconds?: number;
     expires?: number | string;

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;;;;;;;YA2C7B,CAAC;WAAa,CAAC;mBACH,CAAC;;;;;;;;;;;;;;;;;;;;;;;;SAqIH,CAAC;gBACL,CAAC;SAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAjItB;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/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;AA8SD;;;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"}