@bedrockio/model 0.2.0 → 0.2.2

package/README.md

@@ -436,8 +436,7 @@ validation which will:
 - Append the same validation to `Model.getCreateSchema` and
   `Model.getUpdateSchema` to allow this constraint to trickle down to the API.
 
-> :warning: updateOne and updateMany
->
+> [!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
@@ -951,7 +950,7 @@ is set after verification:
 A user is allowed to update the name of their own shop and admins can as well.
 However, only admins can set the owner of the shop:
 
-```json
+```jsonc
 // shop.json
 {
   "name": {
@@ -1010,7 +1009,7 @@ check the document is the same as `authUser`.
 Delete hooks are a powerful way to define what actions are taken on document
 deletion. They are defined in the `onDelete` field of the model definition file:
 
-```json
+```jsonc
 // user.json
 {
   "attributes": {
@@ -1026,7 +1025,7 @@ deletion. They are defined in the `onDelete` field of the model definition file:
       "foreign": {
         Shop: "owner"
       },
-    }
+    },
     "errorOnReferenced": {
       "except": ["AuditEntry"]
     }
@@ -1094,7 +1093,7 @@ 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.
 
-> [!IMPORTANT]  
+> [!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/schema.js

@@ -142,9 +142,6 @@ function attributesToMongoose(attributes) {
   return definition;
 }
 function assertSchemaType(type, path) {
-  if (type === 'Mixed') {
-    throw new Error('Type "Mixed" is not allowed. Use "Object" instead.');
-  }
   if (typeof type === 'string') {
     if (!isMongooseType(type)) {
       const p = path.join('.');

package/dist/cjs/soft-delete.js

@@ -6,8 +6,10 @@ Object.defineProperty(exports, "__esModule", {
 exports.applySoftDelete = applySoftDelete;
 exports.assertUnique = assertUnique;
 exports.hasUniqueConstraints = hasUniqueConstraints;
+var _mongoose = _interopRequireDefault(require("mongoose"));
 var _lodash = require("lodash");
 var _query = require("./query");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function applySoftDelete(schema) {
   applyQueries(schema);
   applyUniqueConstraints(schema);
@@ -219,7 +221,7 @@ function applyUniqueConstraints(schema) {
     return;
   }
   schema.pre('save', async function () {
-    await assertUnique(this.toObject(), {
+    await assertUnique(this, {
       operation: this.isNew ? 'create' : 'update',
       model: this.constructor,
       schema
@@ -340,6 +342,11 @@ function resolveUnique(schema, obj, map = {}, path = []) {
     for (let el of obj) {
       resolveUnique(schema, el, map, path);
     }
+  } else if (obj instanceof _mongoose.default.Document) {
+    obj.schema.eachPath(key => {
+      const val = obj.get(key);
+      resolveUnique(schema, val, map, [...path, key]);
+    });
   } else if (obj && typeof obj === 'object') {
     for (let [key, val] of Object.entries(obj)) {
       resolveUnique(schema, val, map, [...path, key]);

package/dist/cjs/validation.js

@@ -315,11 +315,12 @@ function getSchemaForType(type, options) {
       return _yada.default.boolean();
     case 'Date':
       return _yada.default.date().iso().tag(DATE_TAGS);
-    case 'Mixed':
     case 'Object':
       return _yada.default.object();
     case 'Array':
       return _yada.default.array();
+    case 'Mixed':
+      return _yada.default.any();
     case 'ObjectId':
       if (options.allowExpandedRefs) {
         return REFERENCE_SCHEMA;

package/jest-mongodb-config.js

@@ -1,7 +1,9 @@
+const { devDependencies } = require('./package.json');
+
 module.exports = {
   mongodbMemoryServerOptions: {
     binary: {
-      version: '6.0.2',
+      version: devDependencies.mongodb,
       skipMD5: true,
     },
     autoStart: false,

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@bedrockio/model",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Bedrock utilities for model creation.",
   "type": "module",
   "scripts": {
     "test": "jest",
+    "types": "tsc",
     "lint": "eslint",
     "build": "scripts/build",
-    "types": "tsc",
+    "eject": "scripts/eject.js",
     "prepublishOnly": "yarn build && yarn types"
   },
   "main": "dist/cjs/index.js",
@@ -29,7 +30,7 @@
     "lodash": "^4.17.21"
   },
   "peerDependencies": {
-    "@bedrockio/yada": "^1.0.33",
+    "@bedrockio/yada": "^1.0.34",
     "mongoose": "^6.9.0 || ^7.6.4"
   },
   "devDependencies": {
@@ -37,14 +38,13 @@
     "@babel/core": "^7.20.12",
     "@babel/preset-env": "^7.20.2",
     "@bedrockio/prettier-config": "^1.0.2",
-    "@bedrockio/yada": "^1.0.33",
+    "@bedrockio/yada": "^1.0.34",
     "@shelf/jest-mongodb": "^4.1.7",
-    "babel-plugin-import-replacement": "^1.0.1",
     "eslint": "^8.33.0",
     "eslint-plugin-bedrock": "^1.0.26",
     "jest": "^29.4.1",
     "jest-environment-node": "^29.4.1",
-    "mongodb": "^5.9.1",
+    "mongodb": "^6.2.0",
     "mongoose": "^7.6.4",
     "prettier-eslint": "^15.0.1",
     "typescript": "^4.9.5"

package/src/schema.js

@@ -156,10 +156,6 @@ function attributesToMongoose(attributes) {
 }
 
 function assertSchemaType(type, path) {
-  if (type === 'Mixed') {
-    throw new Error('Type "Mixed" is not allowed. Use "Object" instead.');
-  }
-
   if (typeof type === 'string') {
     if (!isMongooseType(type)) {
       const p = path.join('.');

package/src/soft-delete.js

@@ -1,3 +1,4 @@
+import mongoose from 'mongoose';
 import { isEqual } from 'lodash';
 
 import { wrapQuery } from './query';
@@ -251,7 +252,7 @@ function applyUniqueConstraints(schema) {
   }
 
   schema.pre('save', async function () {
-    await assertUnique(this.toObject(), {
+    await assertUnique(this, {
       operation: this.isNew ? 'create' : 'update',
       model: this.constructor,
       schema,
@@ -367,6 +368,11 @@ function resolveUnique(schema, obj, map = {}, path = []) {
     for (let el of obj) {
       resolveUnique(schema, el, map, path);
     }
+  } else if (obj instanceof mongoose.Document) {
+    obj.schema.eachPath((key) => {
+      const val = obj.get(key);
+      resolveUnique(schema, val, map, [...path, key]);
+    });
   } else if (obj && typeof obj === 'object') {
     for (let [key, val] of Object.entries(obj)) {
       resolveUnique(schema, val, map, [...path, key]);

package/src/validation.js

@@ -333,11 +333,12 @@ function getSchemaForType(type, options) {
       return yd.boolean();
     case 'Date':
       return yd.date().iso().tag(DATE_TAGS);
-    case 'Mixed':
     case 'Object':
       return yd.object();
     case 'Array':
       return yd.array();
+    case 'Mixed':
+      return yd.any();
     case 'ObjectId':
       if (options.allowExpandedRefs) {
         return REFERENCE_SCHEMA;

package/types/include.d.ts

@@ -24,6 +24,9 @@ export const INCLUDE_FIELD_SCHEMA: {
     validate(value: any, options?: {}): Promise<any>;
     clone(meta: any): any;
     toOpenApi(extra: any): any;
+    getAnyType(): {
+        type: string[];
+    };
     getDefault(): {
         default?: undefined;
     } | {

package/types/include.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../src/include.js"],"names":[],"mappings":"AA2BA,gDAuEC;AAMD,uDA4BC;AAGD,2DAIC;AAvHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKG"}
+{"version":3,"file":"include.d.ts","sourceRoot":"","sources":["../src/include.js"],"names":[],"mappings":"AA2BA,gDAuEC;AAMD,uDA4BC;AAGD,2DAIC;AAvHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKG"}

package/types/load.d.ts

@@ -4,73 +4,7 @@
  * @param {string} name
  * @returns mongoose.Model
  */
-export function loadModel(definition: object, name: string): mongoose.Model<any, any, any, any, any, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, any, any, any, {
-    [x: string]: any;
-}, {
-    autoIndex?: boolean;
-    autoCreate?: boolean;
-    bufferCommands?: boolean;
-    bufferTimeoutMS?: number;
-    capped?: number | boolean | {
-        size?: number;
-        max?: number;
-        autoIndexId?: boolean;
-    };
-    collation?: mongoose.mongo.CollationOptions;
-    collectionOptions?: mongoose.mongo.CreateCollectionOptions;
-    timeseries?: mongoose.mongo.TimeSeriesCollectionOptions;
-    expireAfterSeconds?: number;
-    expires?: string | number;
-    collection?: string;
-    discriminatorKey?: string;
-    excludeIndexes?: boolean;
-    id?: boolean;
-    _id?: boolean;
-    minimize?: boolean;
-    optimisticConcurrency?: boolean;
-    pluginTags?: string[];
-    read?: string;
-    writeConcern?: mongoose.mongo.WriteConcern;
-    safe?: boolean | {
-        w?: string | number;
-        wtimeout?: number;
-        j?: boolean;
-    };
-    shardKey?: Record<string, unknown>;
-    strict?: boolean | "throw";
-    strictQuery?: boolean | "throw";
-    toJSON: {
-        getters: boolean;
-        versionKey: boolean;
-        transform: (doc: any, ret: any, options: any) => void;
-    } | mongoose.ToObjectOptions<any>;
-    toObject: {
-        getters: boolean;
-        versionKey: boolean;
-        transform: (doc: any, ret: any, options: any) => void;
-    } | mongoose.ToObjectOptions<any>;
-    typeKey?: string;
-    validateBeforeSave?: boolean;
-    validateModifiedOnly?: boolean;
-    versionKey?: string | boolean;
-    selectPopulatedPaths?: boolean;
-    skipVersioning?: {
-        [key: string]: boolean;
-    };
-    storeSubdocValidationError?: boolean;
-    timestamps: boolean | mongoose.SchemaTimestampsConfig;
-    suppressReservedKeysWarning?: boolean;
-    statics?: {
-        [x: string]: any;
-    };
-    methods?: any;
-    query?: any;
-    castNonArrays?: boolean;
-    virtuals?: mongoose.SchemaOptionsVirtualsPropertyType<any, any, any>;
-    overwriteModels?: boolean;
-}, any, any>> & {
-    [x: string]: any;
-};
+export function loadModel(definition: object, name: string): any;
 /**
  * Loads all model definitions in the given directory.
  * Returns the full loaded model set.

package/types/load.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../src/load.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,sCAJW,MAAM,QACN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAahB;AAED;;;;GAIG;AACH,sCAFW,MAAM,mBAkBhB"}
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../src/load.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,sCAJW,MAAM,QACN,MAAM,OAahB;AAED;;;;GAIG;AACH,sCAFW,MAAM,mBAkBhB"}

package/types/schema.d.ts

@@ -6,9 +6,7 @@
  * @param {mongoose.SchemaOptions} options
  * @returns mongoose.Schema
  */
-export function createSchema(definition: object, options?: mongoose.SchemaOptions): mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, any, any, any, {
-    [x: string]: any;
-}, {
+export function createSchema(definition: object, options?: mongoose.SchemaOptions): mongoose.Schema<any, mongoose.Model<any, any, any, any, any>, any, any, any, any, {
     autoIndex?: boolean;
     autoCreate?: boolean;
     bufferCommands?: boolean;
@@ -18,9 +16,8 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
         max?: number;
         autoIndexId?: boolean;
     };
-    collation?: mongoose.mongo.CollationOptions;
-    collectionOptions?: mongoose.mongo.CreateCollectionOptions;
-    timeseries?: mongoose.mongo.TimeSeriesCollectionOptions;
+    collation?: import("mongoose/node_modules/mongodb").CollationOptions;
+    timeseries?: import("mongoose/node_modules/mongodb").TimeSeriesCollectionOptions;
     expireAfterSeconds?: number;
     expires?: string | number;
     collection?: string;
@@ -32,7 +29,7 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     optimisticConcurrency?: boolean;
     pluginTags?: string[];
     read?: string;
-    writeConcern?: mongoose.mongo.WriteConcern;
+    writeConcern?: import("mongoose/node_modules/mongodb").WriteConcern;
     safe?: boolean | {
         w?: string | number;
         wtimeout?: number;
@@ -45,15 +42,14 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
         getters: boolean;
         versionKey: boolean;
         transform: (doc: any, ret: any, options: any) => void;
-    } | mongoose.ToObjectOptions<any>;
+    } | mongoose.ToObjectOptions;
     toObject: {
         getters: boolean;
         versionKey: boolean;
         transform: (doc: any, ret: any, options: any) => void;
-    } | mongoose.ToObjectOptions<any>;
+    } | mongoose.ToObjectOptions;
     typeKey?: string;
     validateBeforeSave?: boolean;
-    validateModifiedOnly?: boolean;
     versionKey?: string | boolean;
     selectPopulatedPaths?: boolean;
     skipVersioning?: {
@@ -61,16 +57,14 @@ export function createSchema(definition: object, options?: mongoose.SchemaOption
     };
     storeSubdocValidationError?: boolean;
     timestamps: boolean | mongoose.SchemaTimestampsConfig;
-    suppressReservedKeysWarning?: boolean;
-    statics?: {
-        [x: string]: any;
-    };
+    supressReservedKeysWarning?: boolean;
+    statics?: any;
     methods?: any;
     query?: any;
     castNonArrays?: boolean;
     virtuals?: mongoose.SchemaOptionsVirtualsPropertyType<any, any, any>;
     overwriteModels?: boolean;
-}, any, any>;
+}, any>;
 export function normalizeAttributes(arg: any, path?: any[]): any;
 import mongoose from "mongoose";
 //# sourceMappingURL=schema.d.ts.map

package/types/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAoBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAuChC;AAED,iEAsBC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.js"],"names":[],"mappings":"AAoBA;;;;;;;GAOG;AACH,yCAJW,MAAM,YACN,SAAS,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAuChC;AAED,iEAsBC"}

package/types/search.d.ts

@@ -22,6 +22,9 @@ export function searchValidation(options?: {}): {
     validate(value: any, options?: {}): Promise<any>;
     clone(meta: any): any;
     toOpenApi(extra: any): any;
+    getAnyType(): {
+        type: string[];
+    };
     getDefault(): {
         default?: undefined;
     } | {

package/types/search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAeA,gEAmDC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBC"}
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../src/search.js"],"names":[],"mappings":"AAeA,gEAmDC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBC"}

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

@@ -1 +1 @@
-{"version":3,"file":"soft-delete.d.ts","sourceRoot":"","sources":["../src/soft-delete.js"],"names":[],"mappings":"AAIA,mDAIC;AAiRD,oEAsBC;AAgDD,2DAKC"}
+{"version":3,"file":"soft-delete.d.ts","sourceRoot":"","sources":["../src/soft-delete.js"],"names":[],"mappings":"AAKA,mDAIC;AAiRD,oEAsBC;AAgDD,2DAKC"}

package/types/testing.d.ts

@@ -5,7 +5,7 @@
  * [Link](https://github.com/bedrockio/model#testing)
  * @returns mongoose.Model
  */
-export function createTestModel(...args: any[]): mongoose.Model<any, unknown, unknown, unknown, any, any>;
+export function createTestModel(...args: any[]): mongoose.Model<any, unknown, unknown, unknown, any>;
 export function getTestModelName(): string;
 import mongoose from "mongoose";
 //# sourceMappingURL=testing.d.ts.map

package/types/testing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,0GAiBC;AAED,2CAEC"}
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,qGAiBC;AAED,2CAEC"}

package/types/validation.d.ts

@@ -83,6 +83,9 @@ export const OBJECT_ID_SCHEMA: {
     clone(meta: any): any;
     append(schema: any): any;
     toOpenApi(extra: any): any;
+    getAnyType(): {
+        type: string[];
+    };
     getDefault(): {
         default?: undefined;
     } | {

package/types/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAiFA,kDAEC;AAED,oEAkFC;AAsBD,wEAkBC;AAuRD;;;EAEC;AAED;;;EAOC;AA/dD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQK"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.js"],"names":[],"mappings":"AAiFA,kDAEC;AAED,oEAkFC;AAsBD,wEAkBC;AAwRD;;;EAEC;AAED;;;EAOC;AAheD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQK"}