cosa 6.4.0 → 7.0.0

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2022 Losant IoT, Inc.
+Copyright (c) 2023 Losant IoT, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/lib/db.js

@@ -342,6 +342,7 @@ class Database extends EventEmitter {
    * @see {@link https://mongodb.github.io/node-mongodb-native/4.0/interfaces/aggregateoptions.html#maxtimems}
    */
   async aggregate(collectionName, pipeline, options = {}) {
+    pipeline = deserialize(pipeline);
     const collection = await this.collection(collectionName);
     return collection.aggregate(pipeline, {
       readPreference: options.readPreference,

package/lib/model.js

@@ -7,7 +7,9 @@ const { EJSON } = require('bson');
 const Cursor = require('./cursor');
 const errors = require('./errors');
 const { ObjectId } = require('bson');
-const { pathEq, complement, pick, omit, has } = require('omnibelt');
+const {
+  pathEq, complement, pick, omit, has, isEmpty, isPlainObject
+} = require('omnibelt');
 const { buildPropertySchema } = require('./utils');
 const Immutable = require('./immutable');
 Immutable.use(require('./defined-object'));
@@ -243,11 +245,16 @@ const _create = (data, definition) => {
     });
   };
 
-  definition.methods.del = function(path) {
+  definition.methods.del = function(toDelete) {
     const original = this;
     return this.mutate(function() {
-      objectPath.del(this, path);
-      _markAsModified(this, [path], original);
+      if (!Array.isArray(toDelete)) {
+        toDelete = [toDelete];
+      }
+      toDelete.forEach((path) => {
+        objectPath.del(this, path);
+      });
+      _markAsModified(this, toDelete, original);
     });
   };
 
@@ -409,9 +416,17 @@ const define = (definition) => {
 
   definition._schema = _buildSchema(definition);
 
-  const applyGlobalWhere = (query, options) => {
+  const makeSafeQuery = (query, options) => {
+    if (!query || !isPlainObject(query)) {
+      throw new Error('Query must be an object.');
+    }
+
+    if (!options.allowGlobalQuery && isEmpty(query)) {
+      throw new Error('To make an unrestricted query, please set the allowGlobalQuery option.');
+    }
+
     return options.bypassGlobalWhere || !definition.where ?
-      query : { ...definition.where, ...(query || {}) };
+      query : { ...definition.where, ...query };
   };
 
   return {
@@ -432,15 +447,15 @@ const define = (definition) => {
       return Immutable.isImmutableType(obj, definition.name || 'object');
     },
 
-    count: (query, options = {}) => {
-      query = applyGlobalWhere(query, options);
+    count: async (query, options = {}) => {
+      query = makeSafeQuery(query, options);
       const collection = definition.collection;
       debug(`counting ${JSON.stringify(query)} in ${collection}`);
       return db.find(collection, query, { ...options, count: true });
     },
 
     find: async (query, options = {}) => {
-      query = applyGlobalWhere(query, options);
+      query = makeSafeQuery(query, options);
       const collection = definition.collection;
       debug(`finding ${JSON.stringify(query)} in ${collection}`);
       const dbCursor = await db.find(collection, query, options);
@@ -450,16 +465,22 @@ const define = (definition) => {
       return options.array ? cursor.toArray() : cursor;
     },
 
+    exists: async (query, options = {}) => {
+      query = makeSafeQuery(query, options);
+      const collection = definition.collection;
+      return !!(await db.find(collection, query, { ...options, count: true, limit: 1 }));
+    },
+
     findOne: async (query, options = {}) => {
-      query = applyGlobalWhere(query, options);
+      query = makeSafeQuery(query, options);
       const collection = definition.collection;
       debug(`finding one${JSON.stringify(query)} in ${collection}`);
       const result = await db.find(collection, query, { ...options, findOne: true });
       return !result ? null : _create(result, definition);
     },
 
-    update: (query, update, { autoSet = true, ...options } = {}) => {
-      query = applyGlobalWhere(query, options);
+    update: async (query, update, { autoSet = true, ...options } = {}) => {
+      query = makeSafeQuery(query, options);
       const collection = definition.collection;
       if (autoSet) {
         update = { $set: update };
@@ -468,28 +489,40 @@ const define = (definition) => {
       return db.update(collection, query, update, options);
     },
 
-    remove: (query, options = {}) => {
-      query = applyGlobalWhere(query, options);
+    remove: async (query, options = {}) => {
+      query = makeSafeQuery(query, options);
       const collection = definition.collection;
       debug(`removing ${JSON.stringify(query)} from ${collection}`);
       return db.remove(collection, query, options);
     },
 
-    distinct: (key, query, options = {}) => {
-      query = applyGlobalWhere(query, options);
+    distinct: async (key, query, options = {}) => {
+      query = makeSafeQuery(query, options);
       const collection = definition.collection;
       debug(`finding distinct "${key}" ${JSON.stringify(query)} from ${collection}`);
       return db.distinct(collection, key, query, options);
     },
 
-    aggregate: (pipeline, options = {}) => {
+    aggregate: async (pipeline, options = {}) => {
+      if (!Array.isArray(pipeline)) {
+        throw new Error('Aggregation pipeline must be an array.');
+      }
+
+      pipeline = pipeline.slice();
+      if (pipeline[0]?.$match) {
+        pipeline[0] = { ...pipeline[0], $match: makeSafeQuery(pipeline[0].$match, options) };
+      } else {
+        pipeline.unshift({ $match: makeSafeQuery({}, options) });
+      }
+
       const collection = definition.collection;
       debug(`aggregating ${JSON.stringify(pipeline)} from ${collection}`);
-      return db.aggregate(collection, pipeline, options);
+      const dbCursor = await db.aggregate(collection, pipeline, options);
+      return options.array ? dbCursor.toArray() : dbCursor;
     },
 
     project: async (query, value, options = {}) => {
-      query = applyGlobalWhere(query, options);
+      query = makeSafeQuery(query, options);
       const collection = definition.collection;
       debug(`project ${value}, ${JSON.stringify(query)} in ${collection}`);
       let dbCursor = await db.find(collection, query, options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cosa",
-  "version": "6.4.0",
+  "version": "7.0.0",
   "description": "Cosa Models for MongoDB",
   "main": "lib/index.js",
   "engines": {
@@ -35,25 +35,25 @@
     "lib"
   ],
   "dependencies": {
-    "bson": "~4.7.0",
+    "bson": "~4.7.2",
     "clone": "^2.1.2",
     "debug": "^4.3.4",
     "error": "^7.0.2",
     "etag": "^1.8.1",
-    "joi": "^17.6.4",
-    "mongodb": "~4.11.0",
+    "joi": "^17.8.3",
+    "mongodb": "~4.14.0",
     "object-path": "^0.11.8",
     "omnibelt": "^2.1.0"
   },
   "devDependencies": {
-    "@losant/eslint-config-losant": "^1.5.0",
-    "husky": "^8.0.2",
-    "lint-staged": "^13.0.3",
+    "@losant/eslint-config-losant": "^1.6.0",
+    "husky": "^8.0.3",
+    "lint-staged": "^13.1.2",
     "chai": "^4.3.7",
     "chai-as-promised": "^7.1.1",
     "chai-datetime": "^1.8.0",
-    "documentation": "^14.0.0",
-    "mocha": "^10.1.0",
+    "documentation": "^14.0.1",
+    "mocha": "^10.2.0",
     "string-template": "^1.0.0"
   },
   "eslintConfig": {