@orion-js/mongodb 3.2.4 → 3.2.18

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

@@ -13,7 +13,7 @@ exports.default = (collection) => {
         if (!modifier) {
             throw new Error('Modifier is required when making an update');
         }
-        if (collection.model) {
+        if (collection.schema) {
             const schema = collection.getSchema();
             modifier = options.clean !== false ? await (0, cleanModifier_1.default)(schema, modifier) : modifier;
             if (options.validate !== false)

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

@@ -18,7 +18,7 @@ exports.default = (collection) => {
             if (!doc._id) {
                 doc._id = collection.generateId();
             }
-            if (collection.model) {
+            if (collection.schema) {
                 const schema = collection.getSchema();
                 doc = await (0, schema_1.clean)(schema, (0, fromDot_1.default)(doc));
                 await (0, schema_1.validate)(schema, doc);

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

@@ -16,7 +16,7 @@ exports.default = (collection) => {
         if (!doc._id) {
             doc._id = collection.generateId();
         }
-        if (collection.model) {
+        if (collection.schema) {
             const schema = collection.getSchema();
             doc = await (0, schema_1.clean)(schema, (0, fromDot_1.default)(doc));
             await (0, schema_1.validate)(schema, doc);

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/getMethods/updateMany.js

@@ -14,7 +14,7 @@ exports.default = (collection) => {
         if (!modifier) {
             throw new Error('Modifier is required when making an update');
         }
-        if (collection.model) {
+        if (collection.schema) {
             const schema = collection.getSchema();
             modifier = options.clean !== false ? await (0, cleanModifier_1.default)(schema, modifier) : modifier;
             if (options.validate !== false)

package/lib/createCollection/getMethods/updateOne.js

@@ -14,7 +14,7 @@ exports.default = (collection) => {
         if (!modifier) {
             throw new Error('Modifier is required when making an update');
         }
-        if (collection.model) {
+        if (collection.schema) {
             const schema = collection.getSchema();
             modifier = options.clean !== false ? await (0, cleanModifier_1.default)(schema, modifier) : modifier;
             if (options.validate !== false)

package/lib/createCollection/getMethods/upsert.js

@@ -12,7 +12,7 @@ exports.default = (collection) => {
         let modifier = modifierArg;
         let selector = (0, getSelector_1.default)(arguments);
         modifier.$setOnInsert = { ...modifier.$setOnInsert, _id: collection.generateId() };
-        if (collection.model) {
+        if (collection.schema) {
             const schema = collection.getSchema();
             if (options.clean !== false) {
                 selector = (await (0, cleanModifier_1.default)(schema, { $set: selector })).$set;

package/lib/createCollection/getSchemaAndModel.d.ts

@@ -0,0 +1,10 @@
+import { Model } from '@orion-js/models';
+import { Schema } from '@orion-js/schema';
+import { CreateCollectionOptions } from '../types';
+export declare function getModel(options: CreateCollectionOptions): Model;
+export declare function prepareShema(schema: Schema): Schema;
+export declare function getSchema(options: CreateCollectionOptions, optionsModel?: Model): Schema;
+export declare function getSchemaAndModel(options: CreateCollectionOptions): {
+    schema: Schema;
+    model: Model;
+};

package/lib/createCollection/getSchemaAndModel.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaAndModel = exports.getSchema = exports.prepareShema = exports.getModel = void 0;
+const lodash_1 = require("lodash");
+function getModel(options) {
+    if (!options.model)
+        return;
+    return options.model && options.model.getModel ? options.model.getModel() : options.model;
+}
+exports.getModel = getModel;
+function prepareShema(schema) {
+    if (!schema._id) {
+        schema._id = {
+            type: String
+        };
+    }
+    return schema;
+}
+exports.prepareShema = prepareShema;
+function getSchema(options, optionsModel) {
+    if (optionsModel) {
+        const schema = optionsModel ? (0, lodash_1.cloneDeep)(optionsModel.getCleanSchema()) : {};
+        return prepareShema(schema);
+    }
+    // schema is a typed model
+    if (options.schema && options.schema.getModel) {
+        const model = options.schema.getModel();
+        const schema = model ? (0, lodash_1.cloneDeep)(model.getCleanSchema()) : {};
+        return prepareShema(schema);
+    }
+    if (options.schema && (0, lodash_1.isPlainObject)(options.schema)) {
+        return prepareShema(options.schema);
+    }
+}
+exports.getSchema = getSchema;
+function getSchemaAndModel(options) {
+    const model = getModel(options);
+    const schema = getSchema(options, model);
+    return { schema, model };
+}
+exports.getSchemaAndModel = getSchemaAndModel;

package/lib/createCollection/index.js

@@ -9,8 +9,8 @@ const getMethods_1 = require("./getMethods");
 const dataLoader_1 = require("./getMethods/dataLoader");
 const generateId_1 = __importDefault(require("./generateId"));
 const createIndexes_1 = require("./createIndexes");
-const lodash_1 = require("lodash");
 const __1 = require("..");
+const getSchemaAndModel_1 = require("./getSchemaAndModel");
 exports.createIndexesPromises = [];
 const createCollection = (options) => {
     const connectionName = options.connectionName || 'main';
@@ -20,10 +20,11 @@ const createCollection = (options) => {
     }
     const db = orionConnection.db;
     const rawCollection = db.collection(options.name);
-    const model = options.model && options.model.getModel ? options.model.getModel() : options.model;
+    const { schema, model } = (0, getSchemaAndModel_1.getSchemaAndModel)(options);
     const collection = {
         name: options.name,
         connectionName,
+        schema,
         model,
         indexes: options.indexes || [],
         db,
@@ -31,15 +32,7 @@ const createCollection = (options) => {
         connectionPromise: orionConnection.connectionPromise,
         rawCollection,
         generateId: (0, generateId_1.default)(options),
-        getSchema: () => {
-            const schema = (0, lodash_1.cloneDeep)(model.getCleanSchema());
-            if (!schema._id) {
-                schema._id = {
-                    type: 'ID'
-                };
-            }
-            return schema;
-        }
+        getSchema: () => schema
     };
     // helpers
     collection.initItem = (0, initItem_1.default)(collection);
@@ -54,6 +47,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,82 @@ 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');
+    });
+    it('Should validate but not initialize documents when passed typed schema', async () => {
+        const resolve = async (person, { title }, viewer) => {
+            return `${title} ${person.firstName} ${person.lastName}`;
+        };
+        const titleResolver = (0, resolvers_1.modelResolver)({
+            returns: String,
+            resolve
+        });
+        let Person = class Person {
+        };
+        __decorate([
+            (0, typed_model_1.Prop)(),
+            __metadata("design:type", String)
+        ], Person.prototype, "firstName", void 0);
+        __decorate([
+            (0, typed_model_1.Prop)({ max: 3 }),
+            __metadata("design:type", String)
+        ], Person.prototype, "lastName", void 0);
+        __decorate([
+            (0, typed_model_1.ResolverProp)(titleResolver),
+            __metadata("design:type", Object)
+        ], Person.prototype, "title", void 0);
+        Person = __decorate([
+            (0, typed_model_1.TypedSchema)()
+        ], Person);
+        const Persons = (0, _1.default)({
+            name: (0, helpers_1.generateId)(),
+            schema: Person
+        });
+        expect.assertions(3);
+        try {
+            await Persons.insertOne({
+                _id: '1',
+                firstName: 'John',
+                lastName: 'ppoo'
+            });
+        }
+        catch (error) {
+            expect(error.message).toBe('Validation Error: {lastName: stringTooLong}');
+        }
+        await Persons.insertOne({
+            _id: '1',
+            firstName: 'John',
+            lastName: 'Doe'
+        });
+        const person = await Persons.findOne('1');
+        expect(person.firstName).toBe('John');
+        expect(person.title).toBeUndefined();
+    });
 });

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,24 +79,51 @@ 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>;
 export declare type UpdateMany<ModelClass> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: UpdateOptions) => Promise<MongoDB.UpdateResult | MongoDB.Document>;
 export declare type Upsert<ModelClass> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: UpdateOptions) => Promise<MongoDB.UpdateResult>;
 export interface CreateCollectionOptions {
+    /**
+     * The name of the collection on the Mongo Database
+     */
     name: string;
+    /**
+     * The name of the connection to use. The Mongo URL of this connection will be search on env variables.
+     * If not found, the connection url will be `env.mongo_url`
+     * If defined, the connection url will be `env.mongo_url_${name}`
+     */
     connectionName?: string;
+    /**
+     * The schema used for cleaning and validation of the documents
+     */
+    schema?: any;
+    /**
+     * @deprecated Use schema instead. If you use model, all items will be initialized with the model to add resolvers (which are also deprecated)
+     */
     model?: any;
+    /**
+     * The indexes to use
+     */
     indexes?: Array<CollectionIndex>;
+    /**
+     * Select between random id generation o mongo (time based) id generation
+     */
     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;
     connectionName?: string;
+    schema?: Schema;
+    /**
+     * @deprecated Use schema instead. If you use model, all items will be initialized with the model to add resolvers (which are also deprecated)
+     */
     model?: Model;
     indexes: Array<CollectionIndex>;
     generateId: () => string;
@@ -110,6 +144,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.4",
+  "version": "3.2.18",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
@@ -19,10 +19,11 @@
   "dependencies": {
     "@orion-js/env": "^3.2.0",
     "@orion-js/helpers": "^3.2.0",
-    "@orion-js/models": "^3.2.0",
-    "@orion-js/resolvers": "^3.2.0",
-    "@orion-js/schema": "^3.2.0",
-    "@orion-js/typed-model": "^3.2.4",
+    "@orion-js/models": "^3.2.18",
+    "@orion-js/resolvers": "^3.2.18",
+    "@orion-js/schema": "^3.2.18",
+    "@orion-js/services": "^3.2.10",
+    "@orion-js/typed-model": "^3.2.18",
     "dataloader": "2.1.0",
     "dot-object": "2.1.4",
     "mongodb": "4.5.0"
@@ -39,5 +40,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "a1c4cff581b31f24896ec96a0a180d043dbf802a"
+  "gitHead": "95db28fdf82bca1f23a07ea3a0d8f1218b7c1373"
 }