@orion-js/mongodb 3.2.53 → 3.3.6

package/lib/createCollection/createIndexes.d.ts

@@ -1,3 +1,3 @@
-import { Collection } from '..';
-export declare function checkIndexes(collection: Partial<Collection>): Promise<void>;
-export declare function loadIndexes(collection: Partial<Collection>): Promise<string[]>;
+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/generateId.js

@@ -4,7 +4,9 @@ const helpers_1 = require("@orion-js/helpers");
 const bson_1 = require("bson");
 const getIdGenerator = (options) => {
     if (options.idGeneration === 'random') {
-        return () => (0, helpers_1.generateId)();
+        const prefix = options.idPrefix || '';
+        const random = (0, helpers_1.generateId)();
+        return () => `${prefix}${random}`;
     }
     return () => {
         const id = new bson_1.ObjectID();

package/lib/createCollection/generateId.test.js

@@ -1,4 +1,13 @@
 "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 };
 };
@@ -6,6 +15,7 @@ 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();
@@ -17,3 +27,31 @@ it('generates a usable mongo objectId as string', async () => {
     const diff = now.valueOf() - objectId.getTimestamp().valueOf();
     expect(diff).toBeGreaterThan(0);
 });
+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_/);
+});

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

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

package/lib/createCollection/getMethods/countDocuments.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const getSelector_1 = __importDefault(require("./getSelector"));
-exports.default = (collection) => {
+function default_1(collection) {
     const func = async function (selectorArg, options) {
         await collection.connectionPromise;
         const selector = (0, getSelector_1.default)(arguments);
@@ -12,4 +12,5 @@ exports.default = (collection) => {
         return result;
     };
     return func;
-};
+}
+exports.default = default_1;

package/lib/createCollection/getMethods/dataLoader/loadById.d.ts

@@ -1,2 +1,2 @@
-import { Collection, DataLoader } from '../../../types';
-export default function <DocumentType>(collection: Partial<Collection>): DataLoader.LoadById<DocumentType>;
+import { Collection, DataLoader, ModelClassBase } from '../../../types';
+export default function <DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): DataLoader.LoadById<DocumentType>;

package/lib/createCollection/getMethods/dataLoader/loadData.d.ts

@@ -1,2 +1,2 @@
-import { DataLoader, Collection } from '../../../types';
-export default function <ModelClass>(collection: Partial<Collection>): DataLoader.LoadData<ModelClass>;
+import { DataLoader, Collection, ModelClassBase } from '../../../types';
+export default function <DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): DataLoader.LoadData<DocumentType>;

package/lib/createCollection/getMethods/dataLoader/loadMany.d.ts

@@ -1,2 +1,2 @@
-import { Collection, DataLoader } from '../../../types';
-export default function <ModelClass>(collection: Partial<Collection>): DataLoader.LoadMany<ModelClass>;
+import { Collection, DataLoader, ModelClassBase } from '../../../types';
+export default function <DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): DataLoader.LoadMany<DocumentType>;

package/lib/createCollection/getMethods/dataLoader/loadOne.d.ts

@@ -1,2 +1,2 @@
-import { Collection, DataLoader } from '../../../types';
-export default function <ModelClass>(collection: Partial<Collection>): DataLoader.LoadOne<ModelClass>;
+import { Collection, DataLoader, ModelClassBase } from '../../../types';
+export default function <DocumentType extends ModelClassBase>(collection: Partial<Collection<DocumentType>>): DataLoader.LoadOne<DocumentType>;

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

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

package/lib/createCollection/getMethods/deleteMany.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const getSelector_1 = __importDefault(require("./getSelector"));
-exports.default = (collection) => {
+function default_1(collection) {
     const func = async function (selectorArg, options) {
         await collection.connectionPromise;
         const selector = (0, getSelector_1.default)(arguments);
@@ -12,4 +12,5 @@ exports.default = (collection) => {
         return result;
     };
     return func;
-};
+}
+exports.default = default_1;

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

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

package/lib/createCollection/getMethods/deleteOne.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const getSelector_1 = __importDefault(require("./getSelector"));
-exports.default = (collection) => {
+function default_1(collection) {
     const func = async function (selectorArg, options) {
         await collection.connectionPromise;
         const selector = (0, getSelector_1.default)(arguments);
@@ -12,4 +12,5 @@ exports.default = (collection) => {
         return result;
     };
     return func;
-};
+}
+exports.default = default_1;

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

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

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

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

package/lib/createCollection/getMethods/find.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const getSelector_1 = __importDefault(require("./getSelector"));
-exports.default = (collection) => {
+function default_1(collection) {
     const find = function (selectorArg, options) {
         const selector = (0, getSelector_1.default)(arguments);
         const cursor = collection.rawCollection.find(selector, options);
@@ -17,4 +17,5 @@ exports.default = (collection) => {
         return cursor;
     };
     return find;
-};
+}
+exports.default = default_1;

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

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

package/lib/createCollection/getMethods/findOne.js

@@ -4,14 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const getSelector_1 = __importDefault(require("./getSelector"));
-exports.default = (collection) => {
+function default_1(collection) {
     const findOne = async function (selectorArg, options) {
         await collection.connectionPromise;
         const selector = (0, getSelector_1.default)(arguments);
-        const item = await collection.rawCollection.findOne(selector, options);
+        const item = (await collection.rawCollection.findOne(selector, options));
         if (!item)
             return item;
         return collection.initItem(item);
     };
     return findOne;
-};
+}
+exports.default = default_1;

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

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

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

@@ -1,2 +1,3 @@
-import { Document, Filter } from 'mongodb';
-export default function (args: IArguments): Filter<Document>;
+import { Filter } from 'mongodb';
+import { ModelClassBase } from '../../types';
+export default function getSelector<ModelClass extends ModelClassBase>(args: IArguments): Filter<ModelClass>;

package/lib/createCollection/getMethods/getSelector.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const isPlainObject_1 = __importDefault(require("lodash/isPlainObject"));
-function default_1(args) {
+function getSelector(args) {
     if (args.length === 0)
         return {};
     const selector = args[0];
@@ -18,4 +18,4 @@ function default_1(args) {
         _id: 'shouldReturnNull'
     };
 }
-exports.default = default_1;
+exports.default = getSelector;

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

@@ -12,4 +12,5 @@ import insertMany from './insertMany';
 import updateItem from './updateItem';
 import countDocuments from './countDocuments';
 import estimatedDocumentCount from './estimatedDocumentCount';
-export { findOne, find, findOneAndUpdate, insertOne, insertMany, updateOne, updateMany, updateAndFind, updateItem, deleteOne, deleteMany, upsert, estimatedDocumentCount, countDocuments };
+import insertAndFind from './insertAndFind';
+export { findOne, find, findOneAndUpdate, insertOne, insertMany, insertAndFind, 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.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;
+exports.countDocuments = exports.estimatedDocumentCount = exports.upsert = exports.deleteMany = exports.deleteOne = exports.updateItem = exports.updateAndFind = exports.updateMany = exports.updateOne = exports.insertAndFind = 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"));
@@ -32,3 +32,5 @@ const countDocuments_1 = __importDefault(require("./countDocuments"));
 exports.countDocuments = countDocuments_1.default;
 const estimatedDocumentCount_1 = __importDefault(require("./estimatedDocumentCount"));
 exports.estimatedDocumentCount = estimatedDocumentCount_1.default;
+const insertAndFind_1 = __importDefault(require("./insertAndFind"));
+exports.insertAndFind = insertAndFind_1.default;

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

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

package/lib/createCollection/getMethods/insertAndFind.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const isPlainObject_1 = __importDefault(require("lodash/isPlainObject"));
+const fromDot_1 = __importDefault(require("../../helpers/fromDot"));
+const schema_1 = require("@orion-js/schema");
+const wrapErrors_1 = require("./wrapErrors");
+exports.default = (collection) => {
+    const insertAndFind = async (insertDoc, options) => {
+        await collection.connectionPromise;
+        let doc = insertDoc;
+        if (!doc || !(0, isPlainObject_1.default)(doc)) {
+            throw new Error('Insert must receive a document');
+        }
+        if (!doc._id) {
+            doc._id = collection.generateId();
+        }
+        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);
+        }
+        await (0, wrapErrors_1.wrapErrors)(async () => {
+            await collection.rawCollection.insertOne(doc);
+        });
+        return doc;
+    };
+    return insertAndFind;
+};

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

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

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

@@ -0,0 +1,50 @@
+"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 insertOne_1 = __importDefault(require("./insertOne"));
+const helpers_1 = require("@orion-js/helpers");
+const __1 = __importDefault(require(".."));
+const typed_model_1 = require("@orion-js/typed-model");
+describe('insertAndFind', () => {
+    it('should return a function', async () => {
+        const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)() });
+        const insertOne = (0, insertOne_1.default)(Tests);
+        expect(typeof insertOne).toBe('function');
+    });
+    it('inserts and finds a cleaned document', async () => {
+        let TestSchema1 = class TestSchema1 {
+        };
+        __decorate([
+            (0, typed_model_1.Prop)(),
+            __metadata("design:type", String)
+        ], TestSchema1.prototype, "_id", void 0);
+        __decorate([
+            (0, typed_model_1.Prop)({
+                clean: string => `cleaned ${string}`
+            }),
+            __metadata("design:type", String)
+        ], TestSchema1.prototype, "hello", void 0);
+        TestSchema1 = __decorate([
+            (0, typed_model_1.TypedSchema)()
+        ], TestSchema1);
+        const Tests = (0, __1.default)({ name: (0, helpers_1.generateId)(), schema: TestSchema1 });
+        const result = await Tests.insertAndFind({ hello: 'world' });
+        const count = await Tests.estimatedDocumentCount();
+        expect(count).toBe(1);
+        expect(result).toEqual({
+            _id: result._id,
+            hello: 'cleaned world'
+        });
+    });
+});

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

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

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

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

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

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

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

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

package/lib/createCollection/getMethods/updateItem.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const wrapErrors_1 = require("./wrapErrors");
-exports.default = (collection) => {
+function default_1(collection) {
     const updateItem = async function (item, modifier) {
         await collection.connectionPromise;
         const updated = await (0, wrapErrors_1.wrapErrors)(async () => {
-            return await collection.updateAndFind({ _id: item._id }, modifier);
+            return await collection.updateAndFind(item._id, modifier);
         });
         for (const key in item) {
             delete item[key];
@@ -15,4 +15,5 @@ exports.default = (collection) => {
         }
     };
     return updateItem;
-};
+}
+exports.default = default_1;

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

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

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

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

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

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

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

@@ -1 +1 @@
-export declare const wrapErrors: <TFunc extends Function>(operation: TFunc) => Promise<any>;
+export declare const wrapErrors: <TFunc extends () => Promise<any>>(operation: TFunc) => Promise<ReturnType<TFunc>>;

package/lib/createCollection/index.js

@@ -42,6 +42,7 @@ const createCollection = (options) => {
     collection.findOneAndUpdate = (0, getMethods_1.findOneAndUpdate)(collection);
     collection.insertOne = (0, getMethods_1.insertOne)(collection);
     collection.insertMany = (0, getMethods_1.insertMany)(collection);
+    collection.insertAndFind = (0, getMethods_1.insertAndFind)(collection);
     collection.updateOne = (0, getMethods_1.updateOne)(collection);
     collection.updateMany = (0, getMethods_1.updateMany)(collection);
     collection.deleteMany = (0, getMethods_1.deleteMany)(collection);

package/lib/createCollection/initItem.d.ts

@@ -1,3 +1,2 @@
-import { Collection } from '../types';
-declare const _default: (collection: Partial<Collection>) => (doc: any) => any;
-export default _default;
+import { Collection, InitItem, ModelClassBase } from '../types';
+export default function initItem<ModelClass extends ModelClassBase>(collection: Partial<Collection<ModelClass>>): InitItem<ModelClass>;

package/lib/createCollection/initItem.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = (collection) => {
+function initItem(collection) {
     const initItem = doc => {
         if (!doc)
             return doc;
@@ -9,4 +9,5 @@ exports.default = (collection) => {
         return collection.model.initItem(doc);
     };
     return initItem;
-};
+}
+exports.default = initItem;

package/lib/createCollection/typedModel.test.js

@@ -26,6 +26,10 @@ describe('Collections with typed model', () => {
     });
     let Person = class Person {
     };
+    __decorate([
+        (0, typed_model_1.Prop)(),
+        __metadata("design:type", String)
+    ], Person.prototype, "_id", void 0);
     __decorate([
         (0, typed_model_1.Prop)(),
         __metadata("design:type", String)
@@ -109,6 +113,10 @@ describe('Collections with typed model', () => {
         });
         let Person = class Person {
         };
+        __decorate([
+            (0, typed_model_1.Prop)(),
+            __metadata("design:type", String)
+        ], Person.prototype, "_id", void 0);
         __decorate([
             (0, typed_model_1.Prop)(),
             __metadata("design:type", String)

package/lib/types/index.d.ts

@@ -1,37 +1,35 @@
 import * as MongoDB from 'mongodb';
 import { Model } from '@orion-js/models';
-import { Schema } from '@orion-js/schema';
+import { Blackbox, 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;
+declare type RemoveFunctions<T extends ModelClassBase> = Pick<T, {
+    [Key in keyof T]-?: T[Key] extends Function ? never : Key;
+}[keyof T]> & {
+    _id: ModelClassBase['_id'];
 };
-export declare type DocumentWithIdOptional<T> = Omit<T, '_id'> & {
+export declare type ModelClassBase = {
+    _id: string;
+} & Blackbox;
+export declare type DocumentWithIdOptional<T extends ModelClassBase> = Omit<T, '_id'> & {
     /**
      * The ID of the document
      */
-    _id?: string;
+    _id?: T['_id'];
 };
 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]>;
-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 declare type ModelToDocumentType<ModelClass extends ModelClassBase> = RemoveFunctions<ModelClass>;
+export declare type ModelToDocumentTypeWithId<ModelClass extends ModelClassBase> = RemoveFunctions<ModelClass>;
+export declare type ModelToDocumentTypeWithoutId<ModelClass extends ModelClassBase> = DocumentWithoutId<ModelToDocumentType<ModelClass>>;
+export declare type ModelToDocumentTypeWithIdOptional<ModelClass extends ModelClassBase> = DocumentWithIdOptional<ModelToDocumentType<ModelClass>>;
+export declare type ModelToMongoSelector<ModelClass extends ModelClassBase> = MongoSelector<ModelToDocumentType<ModelClass>>;
+export declare type ModelToUpdateFilter<ModelClass extends ModelClassBase> = MongoDB.UpdateFilter<ModelToDocumentTypeWithoutId<ModelClass>> | Partial<ModelToDocumentTypeWithoutId<ModelClass>>;
 export interface CollectionIndex {
     keys: MongoDB.IndexSpecification;
     options?: MongoDB.CreateIndexesOptions;
 }
 declare type KeyOf<T extends object> = Extract<keyof T, string>;
 export declare namespace DataLoader {
-    interface LoadDataOptionsBase<ModelClass> {
+    interface LoadDataOptionsBase<ModelClass extends ModelClassBase> {
         key: KeyOf<ModelToDocumentTypeWithId<ModelClass>>;
         match?: MongoDB.Filter<ModelToDocumentTypeWithId<ModelClass>>;
         sort?: MongoDB.Sort;
@@ -39,20 +37,20 @@ export declare namespace DataLoader {
         timeout?: number;
         debug?: boolean;
     }
-    export interface LoadDataOptions<ModelClass> extends LoadDataOptionsBase<ModelClass> {
+    export interface LoadDataOptions<ModelClass extends ModelClassBase> extends LoadDataOptionsBase<ModelClass> {
         value?: any;
         values?: Array<any>;
     }
-    export interface LoadOneOptions<ModelClass> extends LoadDataOptionsBase<ModelClass> {
+    export interface LoadOneOptions<ModelClass extends ModelClassBase> extends LoadDataOptionsBase<ModelClass> {
         value: any;
     }
-    export type LoadData<ModelClass> = (options: LoadDataOptions<ModelClass>) => Promise<Array<ModelClass>>;
-    export type LoadOne<ModelClass> = (options: LoadOneOptions<ModelClass>) => Promise<ModelClass>;
-    export type LoadMany<ModelClass> = (options: LoadDataOptions<ModelClass>) => Promise<Array<ModelClass>>;
-    export type LoadById<ModelClass> = (id: string) => Promise<ModelClass>;
+    export type LoadData<ModelClass extends ModelClassBase> = (options: LoadDataOptions<ModelClass>) => Promise<Array<ModelClass>>;
+    export type LoadOne<ModelClass extends ModelClassBase> = (options: LoadOneOptions<ModelClass>) => Promise<ModelClass>;
+    export type LoadMany<ModelClass extends ModelClassBase> = (options: LoadDataOptions<ModelClass>) => Promise<Array<ModelClass>>;
+    export type LoadById<ModelClass extends ModelClassBase> = (id: ModelClass['_id']) => Promise<ModelClass>;
     export {};
 }
-export declare type MongoSelector<DocumentType = MongoDB.Document> = string | MongoDB.Filter<DocumentType>;
+export declare type MongoSelector<ModelClass extends ModelClassBase = ModelClassBase> = ModelClass['_id'] | MongoDB.Filter<ModelClass>;
 export interface FindCursor<ModelClass> extends MongoDB.FindCursor {
     toArray: () => Promise<Array<ModelClass>>;
 }
@@ -71,22 +69,21 @@ export interface InsertOptions {
     validate?: boolean;
     mongoOptions?: MongoDB.InsertOneOptions;
 }
-export declare type InitItem<ModelClass> = (doc: MongoDB.Document) => ModelClass;
-export declare type FindOne<ModelClass> = (selector?: ModelToMongoSelector<ModelClass>, options?: MongoDB.FindOptions) => Promise<ModelClass>;
-export declare type Find<ModelClass> = (selector?: ModelToMongoSelector<ModelClass>, options?: MongoDB.FindOptions) => FindCursor<ModelClass>;
-export declare type FindOneAndUpdate<ModelClass> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: FindOneAndUpdateUpdateOptions) => Promise<ModelClass>;
-export declare type UpdateAndFind<ModelClass> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: FindOneAndUpdateUpdateOptions) => Promise<ModelClass>;
-export declare type UpdateItem<ModelClass> = (item: {
-    _id: string;
-} & ModelClass, modifier: ModelToUpdateFilter<ModelClass>) => Promise<void>;
-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 {
+export declare type InitItem<ModelClass extends ModelClassBase> = (doc: any) => ModelClass;
+export declare type FindOne<ModelClass extends ModelClassBase> = (selector?: ModelToMongoSelector<ModelClass>, options?: MongoDB.FindOptions) => Promise<ModelClass>;
+export declare type Find<ModelClass extends ModelClassBase> = (selector?: ModelToMongoSelector<ModelClass>, options?: MongoDB.FindOptions) => FindCursor<ModelClass>;
+export declare type FindOneAndUpdate<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: FindOneAndUpdateUpdateOptions) => Promise<ModelClass>;
+export declare type UpdateAndFind<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: FindOneAndUpdateUpdateOptions) => Promise<ModelClass>;
+export declare type UpdateItem<ModelClass extends ModelClassBase> = (item: ModelClass, modifier: ModelToUpdateFilter<ModelClass>) => Promise<void>;
+export declare type InsertOne<ModelClass extends ModelClassBase> = (doc: ModelToDocumentTypeWithIdOptional<ModelClass>, options?: InsertOptions) => Promise<ModelClass['_id']>;
+export declare type InsertMany<ModelClass extends ModelClassBase> = (doc: Array<ModelToDocumentTypeWithIdOptional<ModelClass>>, options?: InsertOptions) => Promise<Array<ModelClass['_id']>>;
+export declare type InsertAndFind<ModelClass extends ModelClassBase> = (doc: ModelToDocumentTypeWithIdOptional<ModelClass>, options?: InsertOptions) => Promise<ModelClass>;
+export declare type DeleteMany<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, options?: MongoDB.DeleteOptions) => Promise<MongoDB.DeleteResult>;
+export declare type DeleteOne<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, options?: MongoDB.DeleteOptions) => Promise<MongoDB.DeleteResult>;
+export declare type UpdateOne<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: UpdateOptions) => Promise<MongoDB.UpdateResult>;
+export declare type UpdateMany<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: UpdateOptions) => Promise<MongoDB.UpdateResult | MongoDB.Document>;
+export declare type Upsert<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: UpdateOptions) => Promise<MongoDB.UpdateResult>;
+export interface CreateCollectionOptions<ModelClass extends ModelClassBase = ModelClassBase> {
     /**
      * The name of the collection on the Mongo Database
      */
@@ -113,11 +110,15 @@ export interface CreateCollectionOptions {
      * Select between random id generation o mongo (time based) id generation
      */
     idGeneration?: 'mongo' | 'random';
+    /**
+     * ID prefix. Only used if idGeneration is random. Recommended for type checking
+     */
+    idPrefix?: ModelClass['_id'];
 }
-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> {
+export declare type EstimatedDocumentCount<ModelClass extends ModelClassBase> = (options?: MongoDB.EstimatedDocumentCountOptions) => Promise<number>;
+export declare type CountDocuments<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, options?: MongoDB.CountDocumentsOptions) => Promise<number>;
+export declare type CreateCollection = <ModelClass extends ModelClassBase = any>(options: CreateCollectionOptions<ModelClass>) => Collection<ModelClass>;
+export interface Collection<ModelClass extends ModelClassBase = ModelClassBase> {
     name: string;
     connectionName?: string;
     schema?: Schema;
@@ -126,16 +127,17 @@ export interface Collection<ModelClass = any> {
      */
     model?: Model;
     indexes: Array<CollectionIndex>;
-    generateId: () => string;
+    generateId: () => ModelClass['_id'];
     getSchema: () => Schema;
     db: MongoDB.Db;
     client: OrionMongoClient;
-    rawCollection: MongoDB.Collection;
+    rawCollection: MongoDB.Collection<ModelClass>;
     initItem: InitItem<ModelClass>;
     findOne: FindOne<ModelClass>;
     find: Find<ModelClass>;
     insertOne: InsertOne<ModelClass>;
     insertMany: InsertMany<ModelClass>;
+    insertAndFind: InsertAndFind<ModelClass>;
     deleteMany: DeleteMany<ModelClass>;
     deleteOne: DeleteOne<ModelClass>;
     updateOne: UpdateOne<ModelClass>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/mongodb",
-  "version": "3.2.53",
+  "version": "3.3.6",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
@@ -17,14 +17,14 @@
     "upgrade-interactive": "yarn upgrade-interactive"
   },
   "dependencies": {
-    "@orion-js/env": "^3.2.40",
-    "@orion-js/helpers": "^3.2.48",
-    "@orion-js/logger": "^3.2.40",
-    "@orion-js/models": "^3.2.53",
-    "@orion-js/resolvers": "^3.2.53",
-    "@orion-js/schema": "^3.2.53",
-    "@orion-js/services": "^3.2.48",
-    "@orion-js/typed-model": "^3.2.53",
+    "@orion-js/env": "^3.3.6",
+    "@orion-js/helpers": "^3.3.6",
+    "@orion-js/logger": "^3.3.6",
+    "@orion-js/models": "^3.3.6",
+    "@orion-js/resolvers": "^3.3.6",
+    "@orion-js/schema": "^3.3.6",
+    "@orion-js/services": "^3.3.6",
+    "@orion-js/typed-model": "^3.3.6",
     "dataloader": "2.1.0",
     "dot-object": "2.1.4",
     "mongodb": "4.5.0"
@@ -41,5 +41,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "4fea736e98ac00e92f0d0f0ff9ba26ffbc7ff6c7"
+  "gitHead": "d4c33669c0b80c178ad769fd0bd845382d8c6645"
 }