@orion-js/mongodb 3.2.3 → 3.2.14

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

@@ -0,0 +1,3 @@
+import { Collection, CountDocuments } from '../../types';
+declare const _default: <DocumentType>(collection: Partial<Collection>) => CountDocuments<DocumentType>;
+export default _default;

package/lib/createCollection/getMethods/countDocuments.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const getSelector_1 = __importDefault(require("./getSelector"));
+exports.default = (collection) => {
+    const func = async function (selectorArg, options) {
+        const selector = (0, getSelector_1.default)(arguments);
+        const result = await collection.rawCollection.countDocuments(selector, options);
+        return result;
+    };
+    return func;
+};

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

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

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

@@ -0,0 +1,21 @@
+"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(".."));
+describe('countDocuments operation', () => {
+    it('should count all documents', async () => {
+        const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)() });
+        await Tests.insertMany([{ hello: 'world' }, { hello: 'world' }]);
+        const count = await Tests.countDocuments({});
+        expect(count).toBe(2);
+    });
+    it('should count filtering documents', async () => {
+        const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)() });
+        await Tests.insertMany([{ name: '1' }, { name: '2' }]);
+        const count = await Tests.countDocuments({ name: '1' });
+        expect(count).toBe(1);
+    });
+});

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

@@ -0,0 +1,3 @@
+import { Collection, EstimatedDocumentCount } from '../../types';
+declare const _default: <DocumentType>(collection: Partial<Collection>) => EstimatedDocumentCount<DocumentType>;
+export default _default;

package/lib/createCollection/getMethods/estimatedDocumentCount.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (collection) => {
+    const func = async function (options) {
+        const result = await collection.rawCollection.estimatedDocumentCount(options);
+        return result;
+    };
+    return func;
+};

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

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

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

@@ -0,0 +1,15 @@
+"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(".."));
+describe('estimatedDocumentCount operation', () => {
+    it('should count all documents', async () => {
+        const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)() });
+        await Tests.insertMany([{ hello: 'world' }, { hello: 'world' }]);
+        const count = await Tests.estimatedDocumentCount();
+        expect(count).toBe(2);
+    });
+});

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

@@ -10,4 +10,6 @@ import deleteMany from './deleteMany';
 import insertOne from './insertOne';
 import insertMany from './insertMany';
 import updateItem from './updateItem';
-export { findOne, find, findOneAndUpdate, insertOne, insertMany, updateOne, updateMany, updateAndFind, updateItem, deleteOne, deleteMany, upsert };
+import countDocuments from './countDocuments';
+import estimatedDocumentCount from './estimatedDocumentCount';
+export { findOne, find, findOneAndUpdate, insertOne, insertMany, updateOne, updateMany, updateAndFind, updateItem, deleteOne, deleteMany, upsert, estimatedDocumentCount, countDocuments };

package/lib/createCollection/getMethods/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.upsert = exports.deleteMany = exports.deleteOne = exports.updateItem = exports.updateAndFind = exports.updateMany = exports.updateOne = exports.insertMany = exports.insertOne = exports.findOneAndUpdate = exports.find = exports.findOne = void 0;
+exports.countDocuments = exports.estimatedDocumentCount = exports.upsert = exports.deleteMany = exports.deleteOne = exports.updateItem = exports.updateAndFind = exports.updateMany = exports.updateOne = exports.insertMany = exports.insertOne = exports.findOneAndUpdate = exports.find = exports.findOne = void 0;
 const find_1 = __importDefault(require("./find"));
 exports.find = find_1.default;
 const findOne_1 = __importDefault(require("./findOne"));
@@ -28,3 +28,7 @@ const insertMany_1 = __importDefault(require("./insertMany"));
 exports.insertMany = insertMany_1.default;
 const updateItem_1 = __importDefault(require("./updateItem"));
 exports.updateItem = updateItem_1.default;
+const countDocuments_1 = __importDefault(require("./countDocuments"));
+exports.countDocuments = countDocuments_1.default;
+const estimatedDocumentCount_1 = __importDefault(require("./estimatedDocumentCount"));
+exports.estimatedDocumentCount = estimatedDocumentCount_1.default;

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

@@ -15,7 +15,7 @@ it('should return a function', async () => {
 it('insert documents without errors', async () => {
     const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)() });
     await Tests.insertMany([{ hello: 'world' }, { hello: 'world' }]);
-    const count = await Tests.find({}).count();
+    const count = await Tests.estimatedDocumentCount();
     expect(count).toBe(2);
 });
 it('should throw an error when no document is passed', async () => {

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

@@ -16,7 +16,7 @@ describe('InsertOne', () => {
     it('insertOnes a document without errors', async () => {
         const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)() });
         await Tests.insertOne({ hello: 'world' });
-        const count = await Tests.find({}).count();
+        const count = await Tests.estimatedDocumentCount();
         expect(count).toBe(1);
     });
     it('should insertOne documents passing deep validation', async () => {

package/lib/createCollection/index.js

@@ -54,6 +54,9 @@ const createCollection = (options) => {
     collection.deleteMany = (0, getMethods_1.deleteMany)(collection);
     collection.deleteOne = (0, getMethods_1.deleteOne)(collection);
     collection.upsert = (0, getMethods_1.upsert)(collection);
+    // counts
+    collection.estimatedDocumentCount = (0, getMethods_1.estimatedDocumentCount)(collection);
+    collection.countDocuments = (0, getMethods_1.countDocuments)(collection);
     // update and find
     collection.updateAndFind = (0, getMethods_1.updateAndFind)(collection);
     collection.updateItem = (0, getMethods_1.updateItem)(collection);

package/lib/createCollection/typedModel.test.js

@@ -70,4 +70,33 @@ describe('Collections with typed model', () => {
         const title = await person.title({ title: 'Mr.' });
         expect(title).toBe('Mr. John Doe');
     });
+    it('Should allow passing _id on insert', async () => {
+        let PersonOptionalId = class PersonOptionalId {
+        };
+        __decorate([
+            (0, typed_model_1.Prop)(),
+            __metadata("design:type", String)
+        ], PersonOptionalId.prototype, "_id", void 0);
+        __decorate([
+            (0, typed_model_1.Prop)(),
+            __metadata("design:type", String)
+        ], PersonOptionalId.prototype, "firstName", void 0);
+        __decorate([
+            (0, typed_model_1.Prop)({ optional: true }),
+            __metadata("design:type", String)
+        ], PersonOptionalId.prototype, "lastName", void 0);
+        PersonOptionalId = __decorate([
+            (0, typed_model_1.TypedSchema)()
+        ], PersonOptionalId);
+        const Persons = (0, _1.default)({
+            name: (0, helpers_1.generateId)(),
+            model: PersonOptionalId
+        });
+        await Persons.insertOne({
+            _id: '1',
+            firstName: 'John'
+        });
+        const person = await Persons.findOne('1');
+        expect(person.firstName).toBe('John');
+    });
 });

package/lib/index.d.ts

@@ -2,3 +2,4 @@ import createCollection, { createIndexesPromises } from './createCollection';
 export { createCollection, createIndexesPromises };
 export * from './connect';
 export * from './types';
+export * from './service';

package/lib/index.js

@@ -32,3 +32,4 @@ exports.createCollection = createCollection_1.default;
 Object.defineProperty(exports, "createIndexesPromises", { enumerable: true, get: function () { return createCollection_1.createIndexesPromises; } });
 __exportStar(require("./connect"), exports);
 __exportStar(require("./types"), exports);
+__exportStar(require("./service"), exports);

package/lib/service/index.d.ts

@@ -0,0 +1,3 @@
+import { CreateCollectionOptions } from '../types';
+export declare function MongoCollection(options: CreateCollectionOptions): (object: any, propertyName: string, index?: number) => void;
+export declare function Repository(): ClassDecorator;

package/lib/service/index.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.Repository = exports.MongoCollection = void 0;
+const services_1 = require("@orion-js/services");
+const createCollection_1 = __importDefault(require("../createCollection"));
+function MongoCollection(options) {
+    return function (object, propertyName, index) {
+        services_1.Container.registerHandler({
+            object,
+            propertyName,
+            index,
+            value: containerInstance => {
+                if (!object.serviceType || object.serviceType !== 'repo') {
+                    throw new Error('You must pass a class decorated with @Repository if you want to use @MongoCollection');
+                }
+                return (0, createCollection_1.default)(options);
+            }
+        });
+    };
+}
+exports.MongoCollection = MongoCollection;
+function Repository() {
+    return function (target) {
+        (0, services_1.Service)()(target);
+        target.prototype.service = target;
+        target.prototype.serviceType = 'repo';
+    };
+}
+exports.Repository = Repository;

package/lib/service/index.test.d.ts

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

package/lib/service/index.test.js

@@ -0,0 +1,68 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const services_1 = require("@orion-js/services");
+const typed_model_1 = require("@orion-js/typed-model");
+const _1 = require(".");
+describe('Collection as IOC', () => {
+    it('should create the collection and set the methods', async () => {
+        let User = class User {
+        };
+        __decorate([
+            (0, typed_model_1.Prop)(),
+            __metadata("design:type", String)
+        ], User.prototype, "_id", void 0);
+        __decorate([
+            (0, typed_model_1.Prop)(),
+            __metadata("design:type", String)
+        ], User.prototype, "name", void 0);
+        User = __decorate([
+            (0, typed_model_1.TypedSchema)()
+        ], User);
+        let UserRepo = class UserRepo {
+            async createUser(user) {
+                return await this.users.insertOne(user);
+            }
+            async getUserByName(name) {
+                return await this.users.findOne({ name });
+            }
+        };
+        __decorate([
+            (0, _1.MongoCollection)({ name: 'users' }),
+            __metadata("design:type", Object)
+        ], UserRepo.prototype, "users", void 0);
+        UserRepo = __decorate([
+            (0, _1.Repository)()
+        ], UserRepo);
+        const instance = (0, services_1.getInstance)(UserRepo);
+        const userId = await instance.createUser({ name: 'Nico' });
+        const user = await instance.getUserByName('Nico');
+        expect(user._id).toBe(userId);
+    });
+    it('should throw an error when trying to set a collection param in a service that is not a repo', () => {
+        expect.assertions(1);
+        try {
+            let UserErrorRepo = class UserErrorRepo {
+            };
+            __decorate([
+                (0, _1.MongoCollection)({ name: 'users2' }),
+                __metadata("design:type", Object)
+            ], UserErrorRepo.prototype, "users", void 0);
+            UserErrorRepo = __decorate([
+                (0, services_1.Service)()
+            ], UserErrorRepo);
+            const instance = (0, services_1.getInstance)(UserErrorRepo);
+        }
+        catch (error) {
+            expect(error.message).toBe('You must pass a class decorated with @Repository if you want to use @MongoCollection');
+        }
+    });
+});

package/lib/types/index.d.ts

@@ -2,20 +2,27 @@ import * as MongoDB from 'mongodb';
 import { Model } from '@orion-js/models';
 import { Schema } from '@orion-js/schema';
 import { OrionMongoClient } from '../connect/connections';
+declare type RemoveFunctions<T> = OmitByValue<T, Function>;
 export declare type DocumentWithId<T> = T & {
     /**
      * The ID of the document
      */
     _id: string;
 };
+export declare type DocumentWithIdOptional<T> = Omit<T, '_id'> & {
+    /**
+     * The ID of the document
+     */
+    _id?: string;
+};
 export declare type DocumentWithoutId<T> = Omit<T, '_id'>;
 declare type OmitByValue<T, ValueType> = Pick<T, {
     [Key in keyof T]-?: T[Key] extends ValueType ? never : Key;
 }[keyof T]>;
-declare type RemoveFunctions<T> = OmitByValue<T, Function>;
 export declare type ModelToDocumentType<ModelClass> = RemoveFunctions<ModelClass>;
 export declare type ModelToDocumentTypeWithId<ModelClass> = DocumentWithId<RemoveFunctions<ModelClass>>;
 export declare type ModelToDocumentTypeWithoutId<ModelClass> = DocumentWithoutId<ModelToDocumentType<ModelClass>>;
+export declare type ModelToDocumentTypeWithIdOptional<ModelClass> = DocumentWithIdOptional<ModelToDocumentType<ModelClass>>;
 export declare type ModelToMongoSelector<ModelClass> = MongoSelector<ModelToDocumentType<ModelClass>>;
 export declare type ModelToUpdateFilter<ModelClass> = MongoDB.UpdateFilter<ModelToDocumentTypeWithoutId<ModelClass>> | Partial<ModelToDocumentTypeWithoutId<ModelClass>>;
 export interface CollectionIndex {
@@ -72,8 +79,8 @@ export declare type UpdateAndFind<ModelClass> = (selector: ModelToMongoSelector<
 export declare type UpdateItem<ModelClass> = (item: {
     _id: string;
 } & ModelClass, modifier: ModelToUpdateFilter<ModelClass>) => Promise<void>;
-export declare type InsertOne<ModelClass> = (doc: ModelToDocumentTypeWithoutId<ModelClass>, options?: InsertOptions) => Promise<string>;
-export declare type InsertMany<ModelClass> = (doc: Array<ModelToDocumentTypeWithoutId<ModelClass>>, options?: InsertOptions) => Promise<Array<string>>;
+export declare type InsertOne<ModelClass> = (doc: ModelToDocumentTypeWithIdOptional<ModelClass>, options?: InsertOptions) => Promise<string>;
+export declare type InsertMany<ModelClass> = (doc: Array<ModelToDocumentTypeWithIdOptional<ModelClass>>, options?: InsertOptions) => Promise<Array<string>>;
 export declare type DeleteMany<ModelClass> = (selector: ModelToMongoSelector<ModelClass>, options?: MongoDB.DeleteOptions) => Promise<MongoDB.DeleteResult>;
 export declare type DeleteOne<ModelClass> = (selector: ModelToMongoSelector<ModelClass>, options?: MongoDB.DeleteOptions) => Promise<MongoDB.DeleteResult>;
 export declare type UpdateOne<ModelClass> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: UpdateOptions) => Promise<MongoDB.UpdateResult>;
@@ -86,6 +93,8 @@ export interface CreateCollectionOptions {
     indexes?: Array<CollectionIndex>;
     idGeneration?: 'mongo' | 'random';
 }
+export declare type EstimatedDocumentCount<ModelClass> = (options?: MongoDB.EstimatedDocumentCountOptions) => Promise<number>;
+export declare type CountDocuments<ModelClass> = (selector: ModelToMongoSelector<ModelClass>, options?: MongoDB.CountDocumentsOptions) => Promise<number>;
 export declare type CreateCollection = <ModelClass = any>(options: CreateCollectionOptions) => Collection<ModelClass>;
 export interface Collection<ModelClass = any> {
     name: string;
@@ -110,6 +119,8 @@ export interface Collection<ModelClass = any> {
     findOneAndUpdate: FindOneAndUpdate<ModelClass>;
     updateAndFind: UpdateAndFind<ModelClass>;
     updateItem: UpdateItem<ModelClass>;
+    estimatedDocumentCount: EstimatedDocumentCount<ModelClass>;
+    countDocuments: CountDocuments<ModelClass>;
     aggregate: <T = MongoDB.Document>(pipeline?: MongoDB.Document[], options?: MongoDB.AggregateOptions) => MongoDB.AggregationCursor<T>;
     watch: <T = MongoDB.Document>(pipeline?: MongoDB.Document[], options?: MongoDB.ChangeStreamOptions) => MongoDB.ChangeStream<T>;
     loadData: DataLoader.LoadData<ModelClass>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/mongodb",
-  "version": "3.2.3",
+  "version": "3.2.14",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
@@ -22,7 +22,8 @@
     "@orion-js/models": "^3.2.0",
     "@orion-js/resolvers": "^3.2.0",
     "@orion-js/schema": "^3.2.0",
-    "@orion-js/typed-model": "^3.2.3",
+    "@orion-js/services": "^3.2.10",
+    "@orion-js/typed-model": "^3.2.10",
     "dataloader": "2.1.0",
     "dot-object": "2.1.4",
     "mongodb": "4.5.0"
@@ -39,5 +40,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "169123c560388991a3e2d3d7c96682dcb3713523"
+  "gitHead": "87d4cca0154b4beb6e6fa97f298b1440e0c3c231"
 }