@orion-js/mongodb 3.12.0 → 3.13.1

package/lib/createCollection/getMethods/wrapErrors.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapErrors = void 0;
+const schema_1 = require("@orion-js/schema");
+const wrapErrors = async (operation) => {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        if (error.code === 11000) {
+            const regex = /index: (?:.*\.)?\$?(?:([_a-z0-9]*)(?:_\d*)|([_a-z0-9]*))\s*dup key/i;
+            const match = error.message.match(regex);
+            if (!match) {
+                throw new schema_1.ValidationError({
+                    unknownKey: 'notUnique'
+                });
+            }
+            const indexNameText = match[1] || match[2];
+            const names = indexNameText.split(/_[_a-z0-9]_/);
+            const errors = {};
+            for (const name of names) {
+                errors[name] = 'notUnique';
+            }
+            throw new schema_1.ValidationError(errors);
+        }
+        throw error;
+    }
+};
+exports.wrapErrors = wrapErrors;

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/handleError.d.ts

@@ -0,0 +1 @@
+export default function (func: any): (...args: any[]) => Promise<any>;

package/lib/createCollection/handleError.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@orion-js/schema");
+function default_1(func) {
+    return async (...args) => {
+        try {
+            return await func(...args);
+        }
+        catch (error) {
+            if (error.code === 11000) {
+                const regex = /index: (?:.*\.)?\$?(?:([_a-z0-9]*)(?:_\d*)|([_a-z0-9]*))\s*dup key/i;
+                const match = error.message.match(regex);
+                const indexNameText = match[1] || match[2];
+                const names = indexNameText.split(/_[_a-z0-9]_/);
+                const errors = {};
+                for (const name of names) {
+                    errors[name] = 'notUnique';
+                }
+                throw new schema_1.ValidationError(errors);
+            }
+            throw error;
+        }
+    };
+}
+exports.default = default_1;

package/lib/createCollection/index.d.ts

@@ -0,0 +1,4 @@
+import { CreateCollection } from '../types';
+export declare const createIndexesPromises: any[];
+declare const createCollection: CreateCollection;
+export default createCollection;

package/lib/createCollection/index.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIndexesPromises = void 0;
+const initItem_1 = __importDefault(require("./initItem"));
+const getMethods_1 = require("./getMethods");
+const dataLoader_1 = require("./getMethods/dataLoader");
+const generateId_1 = __importDefault(require("./generateId"));
+const createIndexes_1 = require("./createIndexes");
+const __1 = require("..");
+const getSchemaAndModel_1 = require("./getSchemaAndModel");
+exports.createIndexesPromises = [];
+const createCollection = (options) => {
+    const connectionName = options.connectionName || 'main';
+    const orionConnection = (0, __1.getMongoConnection)({ name: connectionName });
+    if (!orionConnection) {
+        throw new Error(`The connection to MongoDB "${connectionName}" was not found`);
+    }
+    const db = orionConnection.db;
+    const rawCollection = db.collection(options.name);
+    const { schema, model } = (0, getSchemaAndModel_1.getSchemaAndModel)(options);
+    const collection = {
+        name: options.name,
+        connectionName,
+        schema,
+        model,
+        indexes: options.indexes || [],
+        db,
+        client: orionConnection,
+        connectionPromise: orionConnection.connectionPromise,
+        rawCollection,
+        generateId: (0, generateId_1.default)(options),
+        getSchema: () => schema
+    };
+    // helpers
+    collection.initItem = (0, initItem_1.default)(collection);
+    // modified orion methods
+    collection.findOne = (0, getMethods_1.findOne)(collection);
+    collection.find = (0, getMethods_1.find)(collection);
+    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);
+    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);
+    // plain passed methods
+    collection.aggregate = (pipeline, options) => collection.rawCollection.aggregate(pipeline, options);
+    collection.watch = (pipeline, options) => collection.rawCollection.watch(pipeline, options);
+    // data loader
+    collection.loadData = (0, dataLoader_1.loadData)(collection);
+    collection.loadById = (0, dataLoader_1.loadById)(collection);
+    collection.loadOne = (0, dataLoader_1.loadOne)(collection);
+    collection.loadMany = (0, dataLoader_1.loadMany)(collection);
+    const createIndexes = async () => {
+        const createIndexPromise = (0, createIndexes_1.loadIndexes)(collection);
+        exports.createIndexesPromises.push(createIndexPromise);
+        collection.createIndexesPromise = createIndexPromise;
+        return createIndexPromise;
+    };
+    collection.createIndexes = createIndexes;
+    if (!process.env.DONT_CREATE_INDEXES_AUTOMATICALLY) {
+        createIndexes();
+    }
+    return collection;
+};
+exports.default = createCollection;

package/lib/createCollection/initItem.d.ts

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

package/lib/createCollection/initItem.js

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

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

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

package/lib/createCollection/typedModel.test.js

@@ -0,0 +1,159 @@
+"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 _1 = __importDefault(require("."));
+const typed_model_1 = require("@orion-js/typed-model");
+const helpers_1 = require("@orion-js/helpers");
+const resolvers_1 = require("@orion-js/resolvers");
+describe('Collections with typed model', () => {
+    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, "_id", void 0);
+    __decorate([
+        (0, typed_model_1.Prop)(),
+        __metadata("design:type", String)
+    ], Person.prototype, "firstName", void 0);
+    __decorate([
+        (0, typed_model_1.Prop)({ max: 10 }),
+        __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.TypedModel)()
+    ], Person);
+    it('Should throw a validation error', async () => {
+        const Persons = (0, _1.default)({
+            name: (0, helpers_1.generateId)(),
+            model: (0, typed_model_1.getModelForClass)(Person)
+        });
+        expect.assertions(1);
+        try {
+            await Persons.insertOne({ firstName: 'John', lastName: 'Really long last name' });
+        }
+        catch (e) {
+            const validationError = e;
+            expect(validationError.validationErrors).toEqual({
+                lastName: 'stringTooLong'
+            });
+        }
+    });
+    it('Should pass the resolvers to the items', async () => {
+        const Persons = (0, _1.default)({
+            name: (0, helpers_1.generateId)(),
+            model: (0, typed_model_1.getModelForClass)(Person)
+        });
+        await Persons.insertOne({
+            firstName: 'John',
+            lastName: 'Doe'
+        });
+        const person = await Persons.findOne({});
+        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, "_id", void 0);
+        __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/helpers/fromDot.d.ts

@@ -0,0 +1 @@
+export default function fromDot(doc: any): any;

package/lib/helpers/fromDot.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 });
+const dot_object_1 = __importDefault(require("dot-object"));
+const toDot_1 = __importDefault(require("./toDot"));
+function fromDot(doc) {
+    doc = (0, toDot_1.default)(doc);
+    return dot_object_1.default.object(doc);
+}
+exports.default = fromDot;

package/lib/helpers/fromDot.test.d.ts

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

package/lib/helpers/fromDot.test.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 });
+const fromDot_1 = __importDefault(require("./fromDot"));
+it('should convert objects from dot notation', async () => {
+    const result = (0, fromDot_1.default)({
+        'person.name': 'Nicolás',
+        'person.framework': 'Orion'
+    });
+    expect(result).toEqual({
+        person: { name: 'Nicolás', framework: 'Orion' }
+    });
+});
+it('should handle object with values that are not in dot notation', async () => {
+    const doc = {
+        'person.name': 'Nicolás',
+        person: { friends: [{ person: { name: 'Joaquín' } }, { person: { name: 'Roberto' } }] }
+    };
+    const result = (0, fromDot_1.default)(doc);
+    expect(result).toEqual({
+        person: {
+            name: 'Nicolás',
+            friends: [{ person: { name: 'Joaquín' } }, { person: { name: 'Roberto' } }]
+        }
+    });
+});
+it('should convert objects with array from dot notation', async () => {
+    const result = (0, fromDot_1.default)({
+        'person.friends': [{ 'person.name': 'Joaquín' }, { 'person.name': 'Roberto' }]
+    });
+    expect(result).toEqual({
+        person: { friends: [{ person: { name: 'Joaquín' } }, { person: { name: 'Roberto' } }] }
+    });
+});
+it('should convert objects with index array from dot notation', async () => {
+    const result = (0, fromDot_1.default)({
+        'person.friends.0.person.name': 'Joaquín',
+        'person.friends.1.person.name': 'Roberto'
+    });
+    expect(result).toEqual({
+        person: {
+            friends: [{ person: { name: 'Joaquín' } }, { person: { name: 'Roberto' } }]
+        }
+    });
+});

package/lib/helpers/toDot.d.ts

@@ -0,0 +1 @@
+export default function (doc: any): any;

package/lib/helpers/toDot.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dot_object_1 = __importDefault(require("dot-object"));
+var dot = new dot_object_1.default('.', false, true, false);
+function default_1(doc) {
+    return dot.dot(doc);
+}
+exports.default = default_1;

package/lib/helpers/toDot.test.d.ts

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

package/lib/helpers/toDot.test.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const toDot_1 = __importDefault(require("./toDot"));
+it('should convert objects to dot notation', async () => {
+    const result = (0, toDot_1.default)({
+        person: { name: 'Nicolás' }
+    });
+    expect(result).toEqual({
+        'person.name': 'Nicolás'
+    });
+});
+it('should convert objects with array to dot notation', async () => {
+    const result = (0, toDot_1.default)({
+        person: { friends: [{ person: { name: 'Joaquín' } }, { person: { name: 'Roberto' } }] }
+    });
+    expect(result).toEqual({
+        'person.friends.0.person.name': 'Joaquín',
+        'person.friends.1.person.name': 'Roberto'
+    });
+});

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+import createCollection, { createIndexesPromises } from './createCollection';
+export { createCollection, createIndexesPromises };
+export * from './connect';
+export * from './types';
+export * from './service';

package/lib/index.js

@@ -0,0 +1,35 @@
+"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;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIndexesPromises = exports.createCollection = void 0;
+const createCollection_1 = __importStar(require("./createCollection"));
+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, ModelClassBase } from '../types';
+export declare function MongoCollection<ModelClass extends ModelClassBase = ModelClassBase>(options: CreateCollectionOptions<ModelClass>): (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,73 @@
+"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',
+                schema: User,
+                idGeneration: 'random',
+                idPrefix: 'user_'
+            }),
+            __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/tests/setup.d.ts

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