@orion-js/mongodb 3.12.0 → 3.13.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Orionjs Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/connect/connections.d.ts

@@ -0,0 +1,13 @@
+import { MongoClient, Db } from 'mongodb';
+export interface OrionMongoClient {
+    client: MongoClient;
+    db: Db;
+    uri: string;
+    dbName: string;
+    connectionPromise: Promise<MongoClient>;
+    connectionName: string;
+}
+export interface OrionMongoConnectionsMap {
+    [key: string]: OrionMongoClient;
+}
+export declare const connections: OrionMongoConnectionsMap;

package/lib/connect/connections.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connections = void 0;
+exports.connections = {};

package/lib/connect/getDBName.d.ts

@@ -0,0 +1 @@
+export default function getDBName(url: string): string;

package/lib/connect/getDBName.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getDBName(url) {
+    let dbName = 'admin';
+    let connectionPart = '';
+    const startConnectionPart = url.indexOf('//') + 2;
+    if (url.indexOf('?') !== -1) {
+        connectionPart = url.substring(startConnectionPart, url.indexOf('?'));
+    }
+    else {
+        connectionPart = url.substring(startConnectionPart);
+    }
+    if (connectionPart.indexOf('.sock') !== -1) {
+        if (connectionPart.indexOf('.sock/') !== -1) {
+            dbName = connectionPart.split('.sock/')[1];
+        }
+    }
+    else if (connectionPart.indexOf('/') !== -1) {
+        dbName = connectionPart.split('/')[1];
+    }
+    return dbName;
+}
+exports.default = getDBName;

package/lib/connect/getMongoConnection.d.ts

@@ -0,0 +1,8 @@
+import { OrionMongoClient } from './connections';
+export declare const allConnectionPromises: any[];
+interface MongoConnectOptions {
+    name: string;
+    uri?: string;
+}
+export declare const getMongoConnection: ({ name, uri }: MongoConnectOptions) => OrionMongoClient;
+export {};

package/lib/connect/getMongoConnection.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMongoConnection = exports.allConnectionPromises = void 0;
+const mongodb_1 = require("mongodb");
+const connections_1 = require("./connections");
+const getDBName_1 = __importDefault(require("./getDBName"));
+const getMongoURLFromEnv_1 = require("./getMongoURLFromEnv");
+const logger_1 = require("@orion-js/logger");
+const helpers_1 = require("@orion-js/helpers");
+exports.allConnectionPromises = [];
+async function connect(client) {
+    try {
+        const result = await client.connect();
+        return result;
+    }
+    catch (error) {
+        logger_1.logger.error(`Error connecting to mongo: ${error.message}. Will retry in 5s`, error);
+        await (0, helpers_1.sleep)(5000);
+        return connect(client);
+    }
+}
+const getMongoConnection = ({ name, uri }) => {
+    uri = uri || (0, getMongoURLFromEnv_1.getMongoURLFromEnv)(name);
+    if (connections_1.connections[name])
+        return connections_1.connections[name];
+    const client = new mongodb_1.MongoClient(uri, {
+        retryReads: true
+    });
+    const connectionPromise = connect(client);
+    exports.allConnectionPromises.push(connectionPromise);
+    const dbName = (0, getDBName_1.default)(uri);
+    const db = client.db(dbName);
+    const mongoClient = {
+        uri,
+        client,
+        connectionPromise,
+        dbName,
+        db,
+        connectionName: name
+    };
+    connections_1.connections[name] = mongoClient;
+    return mongoClient;
+};
+exports.getMongoConnection = getMongoConnection;

package/lib/connect/getMongoConnection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/connect/getMongoConnection.test.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("@orion-js/helpers");
+const _1 = require(".");
+const __1 = require("..");
+describe('Get Mongo Connection', () => {
+    test('Should get mongo connection for main connection', async () => {
+        const mongoConnection = (0, _1.getMongoConnection)({ name: 'main' });
+        await mongoConnection.connectionPromise;
+        expect(mongoConnection).toBeDefined();
+        expect(mongoConnection.uri).toBe(process.env.MONGO_URL);
+    });
+    test('Should get mongo connection for other connections defined by process env', async () => {
+        process.env.MONGO_URL_NICO = process.env.MONGO_URL + 'other';
+        const mongoConnection = (0, _1.getMongoConnection)({ name: 'nico' });
+        await mongoConnection.connectionPromise;
+        expect(mongoConnection).toBeDefined();
+        expect(mongoConnection.uri).toBe(process.env.MONGO_URL_NICO);
+    });
+    test('Should create a collection using custom connection with env', async () => {
+        process.env.MONGO_URL_NICO2 = process.env.MONGO_URL + 'other2';
+        const collection = (0, __1.createCollection)({
+            name: (0, helpers_1.generateId)(),
+            connectionName: 'nico2'
+        });
+        await collection.connectionPromise;
+        expect(collection.connectionName).toBe('nico2');
+        expect(collection.client.uri).toBe(process.env.MONGO_URL_NICO2);
+    });
+    test('Should throw the correct error when no mongo url env is defined', async () => {
+        expect.assertions(1);
+        try {
+            const collection = (0, __1.createCollection)({
+                name: (0, helpers_1.generateId)(),
+                connectionName: 'nico3'
+            });
+            await collection.connectionPromise;
+        }
+        catch (error) {
+            expect(error.message).toBe(`To use the connection "nico3" you must initialize it first calling getMongoConnection({name: "nico3", uri: "MONGOURI"}) or setting the environment variable MONGO_URL_NICO3.`);
+        }
+    });
+});

package/lib/connect/getMongoURLFromEnv.d.ts

@@ -0,0 +1 @@
+export declare const getMongoURLFromEnv: (connectionName: string) => string;

package/lib/connect/getMongoURLFromEnv.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMongoURLFromEnv = void 0;
+const connections_1 = require("./connections");
+const env_1 = require("@orion-js/env");
+const getMongoURLFromEnv = (connectionName) => {
+    if (connectionName === 'main') {
+        if (!(0, env_1.internalGetEnv)('mongo_url', 'MONGO_URL')) {
+            throw new Error('MONGO_URL is required');
+        }
+        return (0, env_1.internalGetEnv)('mongo_url', 'MONGO_URL');
+    }
+    const envName = `mongo_url_${connectionName.toLowerCase()}`;
+    const processEnvName = `MONGO_URL_${connectionName.toUpperCase()}`;
+    const uri = connections_1.connections[connectionName]?.uri ?? (0, env_1.internalGetEnv)(envName, processEnvName);
+    if (!uri) {
+        throw new Error(`To use the connection "${connectionName}" you must initialize it first calling getMongoConnection({name: "${connectionName}", uri: "MONGOURI"}) or setting the environment variable ${processEnvName}.`);
+    }
+    return uri;
+};
+exports.getMongoURLFromEnv = getMongoURLFromEnv;

package/lib/connect/index.d.ts

@@ -0,0 +1,4 @@
+import { connections } from './connections';
+import { OrionMongoClient } from './connections';
+import { allConnectionPromises, getMongoConnection } from './getMongoConnection';
+export { OrionMongoClient, getMongoConnection, connections, allConnectionPromises };

package/lib/connect/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allConnectionPromises = exports.connections = exports.getMongoConnection = void 0;
+const connections_1 = require("./connections");
+Object.defineProperty(exports, "connections", { enumerable: true, get: function () { return connections_1.connections; } });
+const getMongoConnection_1 = require("./getMongoConnection");
+Object.defineProperty(exports, "allConnectionPromises", { enumerable: true, get: function () { return getMongoConnection_1.allConnectionPromises; } });
+Object.defineProperty(exports, "getMongoConnection", { enumerable: true, get: function () { return getMongoConnection_1.getMongoConnection; } });

package/lib/createCollection/createIndexPromisesTest.d.ts

@@ -0,0 +1 @@
+export declare const MockTests: import("..").Collection<any>;

package/lib/createCollection/createIndexPromisesTest.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockTests = void 0;
+const helpers_1 = require("@orion-js/helpers");
+const _1 = __importDefault(require("."));
+exports.MockTests = (0, _1.default)({
+    name: (0, helpers_1.generateId)(),
+    indexes: [{ keys: { a: 1 }, options: { unique: true } }]
+});

package/lib/createCollection/createIndexes.d.ts

@@ -0,0 +1,3 @@
+import { Collection, ModelClassBase } from '..';
+export declare function checkIndexes<DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): Promise<void>;
+export declare function loadIndexes<DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): Promise<string[]>;

package/lib/createCollection/createIndexes.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadIndexes = exports.checkIndexes = void 0;
+const mongodb_1 = require("mongodb");
+function matchingDefinition(defIndex, curIndex) {
+    if (defIndex.options && defIndex.options.name === curIndex.name)
+        return true;
+    const defIndexName = Object.keys(defIndex.keys)
+        .map(key => `${key}_${defIndex.keys[key]}`)
+        .join('_');
+    return defIndexName === curIndex.name;
+}
+async function checkIndexes(collection) {
+    let currentIndexes = [];
+    try {
+        currentIndexes = await collection.rawCollection.indexes();
+    }
+    catch (error) {
+        if (error.codeName !== 'NamespaceNotFound')
+            throw error;
+    }
+    const indexesToDelete = collection.indexes
+        ? currentIndexes.filter(index => index.name !== '_id_' &&
+            !collection.indexes.find(definitionIndex => matchingDefinition(definitionIndex, index)))
+        : currentIndexes;
+    if (indexesToDelete.length > 0) {
+        console.warn(`${indexesToDelete.length} unexpected indexes found in collection "${collection.name}": ${indexesToDelete
+            .map(i => i.name)
+            .join(', ')} | Delete the index or fix the collection definition`);
+    }
+}
+exports.checkIndexes = checkIndexes;
+async function loadIndexes(collection) {
+    if (!collection.indexes)
+        return;
+    if (!collection.indexes.length)
+        return;
+    await collection.client.connectionPromise;
+    const results = Promise.all(collection.indexes.map(async ({ keys, options }) => {
+        try {
+            return await collection.rawCollection.createIndex(keys, options);
+        }
+        catch (error) {
+            if (error.code === 85) {
+                console.info('Will delete index to create the new version');
+                const indexName = error.message.split('name: ')[1].split(' ')[0];
+                await collection.rawCollection.dropIndex(indexName);
+                console.info('Index was deleted, creating new index');
+                const result = await collection.rawCollection.createIndex(keys, options);
+                console.info('Index updated correctly');
+                return result;
+            }
+            else if (error instanceof mongodb_1.MongoExpiredSessionError) {
+                // this errors is thrown when we are on tests environment
+                // but it's not a problem never, index will be created on the next connection
+            }
+            else {
+                console.error(`Error creating index for collection ${collection.name}: ${error.message}`);
+                console.error(error);
+                return error.message;
+            }
+        }
+    }));
+    await checkIndexes(collection);
+    return results;
+}
+exports.loadIndexes = loadIndexes;

package/lib/createCollection/createIndexes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/createCollection/createIndexes.test.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("@orion-js/helpers");
+const _1 = __importStar(require("."));
+describe('Test indexes', () => {
+    it('Should store all create indexes promises in the array', async () => {
+        const collection = (0, _1.default)({
+            name: (0, helpers_1.generateId)(),
+            indexes: [{ keys: { a: 1 }, options: { unique: true } }]
+        });
+        expect(_1.createIndexesPromises[0]).toBe(collection.createIndexesPromise);
+        expect(_1.createIndexesPromises.length).toBe(1);
+    });
+    it('Should create collection indexes correctly', async () => {
+        const collection = (0, _1.default)({
+            name: (0, helpers_1.generateId)(),
+            indexes: [{ keys: { a: 1 }, options: { unique: true } }]
+        });
+        const results = await collection.createIndexesPromise;
+        expect(results).toEqual(['a_1']);
+    });
+    it('Should handle error when cant create indexes', async () => {
+        const collectionName = (0, helpers_1.generateId)();
+        const collection1 = (0, _1.default)({
+            name: collectionName
+        });
+        await collection1.insertOne({ a: 1 });
+        await collection1.insertOne({ a: 1 });
+        console.error = jest.fn();
+        const collection2 = (0, _1.default)({
+            name: collectionName,
+            indexes: [{ keys: { a: 1 }, options: { unique: true } }]
+        });
+        const result = await collection2.createIndexesPromise;
+        expect(result[0]).toContain('E11000');
+        expect(console.error).toHaveBeenCalled();
+    });
+    it('Should log indexes that have to be deleted', async () => {
+        const collectionName = (0, helpers_1.generateId)();
+        const collection1 = (0, _1.default)({
+            name: collectionName,
+            indexes: [{ keys: { a: 1 }, options: { unique: true } }]
+        });
+        await collection1.createIndexesPromise;
+        console.warn = jest.fn();
+        const collection2 = (0, _1.default)({
+            name: collectionName,
+            indexes: [{ keys: { ba: 1 }, options: { unique: true } }]
+        });
+        await collection2.createIndexesPromise;
+        expect(console.warn).toHaveBeenCalled();
+    });
+    it('Should upgrade a index correctly', async () => {
+        const collectionName = (0, helpers_1.generateId)();
+        const collection1 = (0, _1.default)({
+            name: collectionName,
+            indexes: [{ keys: { name: 1 } }]
+        });
+        await collection1.createIndexesPromise;
+        console.info = jest.fn();
+        const collection2 = (0, _1.default)({
+            name: collectionName,
+            indexes: [{ keys: { name: 1 }, options: { unique: true } }]
+        });
+        await collection2.createIndexesPromise;
+        expect(console.warn).toHaveBeenCalled();
+    });
+});

package/lib/createCollection/createIndexesPromise.test.d.ts

@@ -0,0 +1 @@
+export declare const Tests: import("..").Collection<any>;

package/lib/createCollection/createIndexesPromise.test.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tests = void 0;
+const helpers_1 = require("@orion-js/helpers");
+const _1 = __importDefault(require("."));
+const __1 = require("..");
+jest.mock('./createIndexPromisesTest');
+exports.Tests = (0, _1.default)({
+    name: (0, helpers_1.generateId)(),
+    indexes: [{ keys: { a: 1 }, options: { unique: true } }]
+});
+beforeEach(async () => {
+    await Promise.all(__1.allConnectionPromises);
+});
+describe('createIndexesPromise', () => {
+    it('should correctly handle the promise for tests', async () => {
+        const userId = await exports.Tests.insertOne({
+            name: 'Nico'
+        });
+        const user = await exports.Tests.findOne(userId);
+        expect(user.name).toBe('Nico');
+    });
+    it('should be able to close the index handlers on the global config', async () => {
+        (0, _1.default)({
+            name: (0, helpers_1.generateId)(),
+            indexes: [{ keys: { a: 1 }, options: { unique: true } }]
+        });
+    });
+});

package/lib/createCollection/generateId.d.ts

@@ -0,0 +1,3 @@
+import { CreateCollectionOptions } from '..';
+declare const getIdGenerator: (options: CreateCollectionOptions) => (() => string);
+export default getIdGenerator;

package/lib/createCollection/generateId.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("@orion-js/helpers");
+const bson_1 = require("bson");
+const getIdGenerator = (options) => {
+    if (options.idPrefix || options.idGeneration === 'uuid') {
+        return () => {
+            const prefix = options.idPrefix || '';
+            const random = (0, helpers_1.generateUUID)();
+            return `${prefix}${random}`;
+        };
+    }
+    if (options.idGeneration === 'random') {
+        return () => {
+            const prefix = options.idPrefix || '';
+            const random = (0, helpers_1.generateId)();
+            return `${prefix}${random}`;
+        };
+    }
+    return () => {
+        const id = new bson_1.ObjectId();
+        return id.toString();
+    };
+};
+exports.default = getIdGenerator;

package/lib/createCollection/generateId.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/createCollection/generateId.test.js

@@ -0,0 +1,108 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("@orion-js/helpers");
+const index_1 = __importDefault(require("./index"));
+const bson_1 = require("bson");
+const typed_model_1 = require("@orion-js/typed-model");
+it('generates a usable mongo objectId as string', async () => {
+    const Tests = (0, index_1.default)({ name: (0, helpers_1.generateId)() });
+    const now = new Date();
+    const userId = await Tests.insertOne({
+        name: 'Nico'
+    });
+    const objectId = bson_1.ObjectId.createFromHexString(userId);
+    expect(objectId.toString()).toBe(userId);
+    const diff = now.valueOf() - objectId.getTimestamp().valueOf();
+    expect(diff).toBeGreaterThan(0);
+});
+it('generates a ids with uuidv4', async () => {
+    let Schema = class Schema {
+    };
+    __decorate([
+        (0, typed_model_1.Prop)(),
+        __metadata("design:type", String)
+    ], Schema.prototype, "_id", void 0);
+    __decorate([
+        (0, typed_model_1.Prop)(),
+        __metadata("design:type", String)
+    ], Schema.prototype, "name", void 0);
+    Schema = __decorate([
+        (0, typed_model_1.TypedSchema)()
+    ], Schema);
+    const Tests = (0, index_1.default)({
+        name: (0, helpers_1.generateId)(),
+        schema: Schema,
+        idPrefix: 'prefix-'
+    });
+    const userId = await Tests.insertOne({
+        name: 'Nico'
+    });
+    expect(userId).toMatch(/^prefix\-/);
+});
+it('generates a ids with a prefix', async () => {
+    let Schema = class Schema {
+    };
+    __decorate([
+        (0, typed_model_1.Prop)(),
+        __metadata("design:type", String)
+    ], Schema.prototype, "_id", void 0);
+    __decorate([
+        (0, typed_model_1.Prop)(),
+        __metadata("design:type", String)
+    ], Schema.prototype, "name", void 0);
+    Schema = __decorate([
+        (0, typed_model_1.TypedSchema)()
+    ], Schema);
+    const Tests = (0, index_1.default)({
+        name: (0, helpers_1.generateId)(),
+        schema: Schema,
+        idGeneration: 'random',
+        idPrefix: 'pref_'
+    });
+    const userId = await Tests.insertOne({
+        name: 'Nico'
+    });
+    const item = await Tests.findOne(userId);
+    // no te deja usar otra cosa que no sea con el prefix
+    await Tests.updateOne({ _id: 'pref_123' }, { $set: { name: 'Nicolás' } });
+    expect(userId).toMatch(/^pref_/);
+});
+it('generates a ids with a distinct type', async () => {
+    let Schema = class Schema {
+    };
+    __decorate([
+        (0, typed_model_1.Prop)(),
+        __metadata("design:type", String)
+    ], Schema.prototype, "_id", void 0);
+    __decorate([
+        (0, typed_model_1.Prop)(),
+        __metadata("design:type", String)
+    ], Schema.prototype, "name", void 0);
+    Schema = __decorate([
+        (0, typed_model_1.TypedSchema)()
+    ], Schema);
+    const Tests = (0, index_1.default)({
+        name: (0, helpers_1.generateId)(),
+        schema: Schema
+    });
+    const userId = await Tests.insertOne({
+        name: 'Nico'
+    });
+    await Tests.findOne(userId);
+    // This should throw an error
+    // await Tests.findOne(anId)
+    const anId = '123';
+    await Tests.findOne(anId);
+});

package/lib/createCollection/getMethods/aggregate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/createCollection/getMethods/aggregate.test.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("@orion-js/helpers");
+const __1 = __importDefault(require(".."));
+it('ensuring the options are passed properly to the aggregate command', async () => {
+    const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)() });
+    const cursorDefault = Tests.aggregate([{ $match: {} }]);
+    expect(cursorDefault.readPreference.mode).toBe('primary');
+    const cursorSecondary = Tests.aggregate([
+        {
+            $match: {}
+        }
+    ], {
+        readPreference: 'secondary'
+    });
+    expect(cursorSecondary.readPreference.mode).toBe('secondary');
+});

package/lib/createCollection/getMethods/cleanModifier.d.ts

@@ -0,0 +1,4 @@
+import * as MongoDB from 'mongodb';
+export default function cleanModifier(schema: any, modifier: any, { isUpsert }?: {
+    isUpsert: boolean;
+}): Promise<MongoDB.UpdateFilter<MongoDB.BSON.Document>>;