@orion-js/mongodb 3.11.8 → 3.12.0

package/lib/service/index.js

@@ -1,32 +0,0 @@
-"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

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

package/lib/service/index.test.js

@@ -1,73 +0,0 @@
-"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

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

package/lib/tests/setup.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const __1 = require("..");
-const connections_1 = require("../connect/connections");
-const url = `${global.__MONGO_URI__}jest`;
-process.env.MONGO_URL = url;
-beforeAll(async () => {
-    const connection = (0, __1.getMongoConnection)({ name: 'main' });
-    await connection.connectionPromise;
-});
-afterAll(async () => {
-    /**
-     * We need to wait on indexes promises to be resolved to close all the handlers
-     */
-    await Promise.all(__1.createIndexesPromises);
-    for (const connectionName in connections_1.connections) {
-        const connection = connections_1.connections[connectionName];
-        await connection.client.close();
-    }
-});

package/lib/types/index.d.ts

@@ -1,178 +0,0 @@
-import * as MongoDB from 'mongodb';
-import { Model } from '@orion-js/models';
-import { Blackbox, Schema } from '@orion-js/schema';
-import { OrionMongoClient } from '../connect/connections';
-type RemoveFunctions<T extends ModelClassBase> = Pick<T, {
-    [Key in keyof T]-?: T[Key] extends Function ? never : Key;
-}[keyof T]> & {
-    _id: ModelClassBase['_id'];
-};
-export type ModelClassBase = {
-    _id: string;
-} & Blackbox;
-export type DocumentWithIdOptional<T extends ModelClassBase> = Omit<T, '_id'> & {
-    /**
-     * The ID of the document
-     */
-    _id?: T['_id'];
-};
-export type DocumentWithoutId<T> = Omit<T, '_id'>;
-export type ModelToDocumentType<ModelClass extends ModelClassBase> = RemoveFunctions<ModelClass>;
-export type ModelToDocumentTypeWithId<ModelClass extends ModelClassBase> = RemoveFunctions<ModelClass>;
-export type ModelToDocumentTypeWithoutId<ModelClass extends ModelClassBase> = DocumentWithoutId<ModelToDocumentType<ModelClass>>;
-export type ModelToDocumentTypeWithIdOptional<ModelClass extends ModelClassBase> = DocumentWithIdOptional<ModelToDocumentType<ModelClass>>;
-export type ModelToMongoSelector<ModelClass extends ModelClassBase> = MongoSelector<ModelToDocumentType<ModelClass>>;
-export type ModelToUpdateFilter<ModelClass extends ModelClassBase> = MongoDB.UpdateFilter<ModelToDocumentTypeWithoutId<ModelClass>> | Partial<ModelToDocumentTypeWithoutId<ModelClass>>;
-export interface CollectionIndex {
-    keys: MongoDB.IndexSpecification;
-    options?: MongoDB.CreateIndexesOptions;
-}
-export declare namespace DataLoader {
-    interface LoadDataOptionsBase<ModelClass extends ModelClassBase> {
-        key: keyof ModelClass;
-        match?: MongoFilter<ModelClass>;
-        sort?: MongoDB.Sort;
-        project?: MongoDB.Document;
-        timeout?: number;
-        debug?: boolean;
-    }
-    export interface LoadDataOptions<ModelClass extends ModelClassBase> extends LoadDataOptionsBase<ModelClass> {
-        value?: any;
-        values?: Array<any>;
-    }
-    export interface LoadOneOptions<ModelClass extends ModelClassBase> extends LoadDataOptionsBase<ModelClass> {
-        value: any;
-    }
-    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 type MongoFilter<ModelClass extends ModelClassBase = ModelClassBase> = MongoDB.Filter<ModelClass> & ({
-    _id?: ModelClass['_id'];
-} | {
-    _id?: {
-        $in: ModelClass['_id'][];
-    };
-});
-export type MongoSelector<ModelClass extends ModelClassBase = ModelClassBase> = ModelClass['_id'] | MongoFilter<ModelClass>;
-export interface FindCursor<ModelClass> extends MongoDB.FindCursor {
-    toArray: () => Promise<Array<ModelClass>>;
-}
-export interface UpdateOptions {
-    clean?: boolean;
-    validate?: boolean;
-    mongoOptions?: MongoDB.UpdateOptions;
-}
-export interface FindOneAndUpdateUpdateOptions {
-    clean?: boolean;
-    validate?: boolean;
-    mongoOptions?: MongoDB.FindOneAndUpdateOptions;
-}
-export interface InsertOptions {
-    clean?: boolean;
-    validate?: boolean;
-    mongoOptions?: MongoDB.InsertOneOptions;
-}
-export type InitItem<ModelClass extends ModelClassBase> = (doc: any) => ModelClass;
-export type FindOne<ModelClass extends ModelClassBase> = (selector?: ModelToMongoSelector<ModelClass>, options?: MongoDB.FindOptions) => Promise<ModelClass>;
-export type Find<ModelClass extends ModelClassBase> = (selector?: ModelToMongoSelector<ModelClass>, options?: MongoDB.FindOptions) => FindCursor<ModelClass>;
-export type FindOneAndUpdate<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: FindOneAndUpdateUpdateOptions) => Promise<ModelClass>;
-export type UpdateAndFind<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: FindOneAndUpdateUpdateOptions) => Promise<ModelClass>;
-export type UpdateItem<ModelClass extends ModelClassBase> = (item: ModelClass, modifier: ModelToUpdateFilter<ModelClass>, options?: FindOneAndUpdateUpdateOptions) => Promise<void>;
-export type InsertOne<ModelClass extends ModelClassBase> = (doc: ModelToDocumentTypeWithIdOptional<ModelClass>, options?: InsertOptions) => Promise<ModelClass['_id']>;
-export type InsertMany<ModelClass extends ModelClassBase> = (doc: Array<ModelToDocumentTypeWithIdOptional<ModelClass>>, options?: InsertOptions) => Promise<Array<ModelClass['_id']>>;
-export type InsertAndFind<ModelClass extends ModelClassBase> = (doc: ModelToDocumentTypeWithIdOptional<ModelClass>, options?: InsertOptions) => Promise<ModelClass>;
-export type DeleteMany<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, options?: MongoDB.DeleteOptions) => Promise<MongoDB.DeleteResult>;
-export type DeleteOne<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, options?: MongoDB.DeleteOptions) => Promise<MongoDB.DeleteResult>;
-export type UpdateOne<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: UpdateOptions) => Promise<MongoDB.UpdateResult>;
-export type UpdateMany<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, modifier: ModelToUpdateFilter<ModelClass>, options?: UpdateOptions) => Promise<MongoDB.UpdateResult | MongoDB.Document>;
-export 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
-     */
-    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' | 'uuid';
-    /**
-     * ID prefix. idGeneration will be forced to random. Recommended for type checking
-     */
-    idPrefix?: ModelClass['_id'];
-}
-export type EstimatedDocumentCount<ModelClass extends ModelClassBase> = (options?: MongoDB.EstimatedDocumentCountOptions) => Promise<number>;
-export type CountDocuments<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, options?: MongoDB.CountDocumentsOptions) => Promise<number>;
-export type CreateCollection = <ModelClass extends ModelClassBase = any>(options: CreateCollectionOptions<ModelClass>) => Collection<ModelClass>;
-export interface Collection<ModelClass extends ModelClassBase = ModelClassBase> {
-    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: () => ModelClass['_id'];
-    getSchema: () => Schema;
-    db: MongoDB.Db;
-    client: OrionMongoClient;
-    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>;
-    updateMany: UpdateMany<ModelClass>;
-    upsert: Upsert<ModelClass>;
-    findOneAndUpdate: FindOneAndUpdate<ModelClass>;
-    /**
-     * Updates a document and returns the updated document with the changes
-     */
-    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>;
-    loadOne: DataLoader.LoadOne<ModelClass>;
-    loadMany: DataLoader.LoadMany<ModelClass>;
-    loadById: DataLoader.LoadById<ModelClass>;
-    /**
-     * Use this function if you are using tests and you pass the
-     * env var DONT_CREATE_INDEXES_AUTOMATICALLY and you need to
-     * create the indexes for this collection
-     */
-    createIndexes: () => Promise<string[]>;
-    createIndexesPromise: Promise<string[]>;
-    connectionPromise: Promise<MongoDB.MongoClient>;
-}
-export type DistinctDocumentId<DistinctId extends string> = string & {
-    __TYPE__: `DistinctDocumentId<${DistinctId}>`;
-};
-export {};

package/lib/types/index.js

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

package/lib/types/types.test.d.ts

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

package/lib/types/types.test.js

@@ -1,59 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const helpers_1 = require("@orion-js/helpers");
-const resolvers_1 = require("@orion-js/resolvers");
-const typed_model_1 = require("@orion-js/typed-model");
-const index_1 = __importDefault(require("../createCollection/index"));
-it('uses correctly typescript for collections', async () => {
-    const fullName = (0, resolvers_1.modelResolver)({
-        returns: String,
-        async resolve(user) {
-            return `${user.firstName} ${user.lastName}`;
-        }
-    });
-    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, "firstName", void 0);
-    __decorate([
-        (0, typed_model_1.Prop)(),
-        __metadata("design:type", String)
-    ], User.prototype, "lastName", void 0);
-    __decorate([
-        (0, typed_model_1.ResolverProp)(fullName),
-        __metadata("design:type", Object)
-    ], User.prototype, "fullName", void 0);
-    User = __decorate([
-        (0, typed_model_1.TypedSchema)()
-    ], User);
-    const Users = (0, index_1.default)({ name: (0, helpers_1.generateId)(), model: User, idPrefix: `userId-` });
-    const userId = await Users.insertOne({
-        firstName: 'Nico',
-        lastName: 'López'
-    });
-    const user1 = await Users.findOne({ _id: userId });
-    expect(user1.firstName).toBe('Nico');
-    expect(await user1.fullName()).toBe('Nico López');
-    await Users.updateOne(userId, { $set: { firstName: 'Nicolás' } });
-    const user2 = await Users.findOne({ lastName: 'López' });
-    expect(user2.firstName).toBe('Nicolás');
-    await Users.deleteOne({ _id: user2._id });
-});