@villedemontreal/mongo 6.7.1 → 6.7.2

package/src/plugins/pagination/index.test.ts

@@ -18,34 +18,37 @@ const bookSchema = new mongoose.Schema({
   date: Date,
   author: {
     type: String,
-    ref: 'Author'
-  }
+    ref: 'Author',
+  },
 });
 
 bookSchema.plugin(mongoosePaginate);
 const bookModel: any = mongoose.model('Book', bookSchema);
 
 describe('plugin pagination', () => {
-  before(async function() {
+  before(async function () {
     this.timeout(120000);
 
     // Makes sure Mongoose is mocked, but not in Jenkins as we will start a dedicated mongodb container.
-    const mockedDb = await mongoUtils.mockMongoose(this, constants.testsConfig.mockServer.serverVersion);
+    const mockedDb = await mongoUtils.mockMongoose(
+      this,
+      constants.testsConfig.mockServer.serverVersion
+    );
     const connString = mockedDb.getUri();
     await mongoose.connect(connString, { useNewUrlParser: true });
   });
 
-  before(async function() {
+  before(async function () {
     this.timeout(10000);
     let book;
     const books: any = [];
     const date = new Date();
-    return authorModel.create({ name: 'Arthur Conan Doyle' }).then(author => {
+    return authorModel.create({ name: 'Arthur Conan Doyle' }).then((author) => {
       for (let i = 1; i <= 100; i++) {
         book = new bookModel({
-          title: 'Book #' + i,
+          title: `Book #${i}`,
           date: new Date(date.getTime() + i),
-          author: author._id
+          author: author._id,
         });
         books.push(book);
       }
@@ -58,7 +61,7 @@ describe('plugin pagination', () => {
     expect(promise.then).to.be.an.instanceof(Function);
   });
 
-  it('calls callback', done => {
+  it('calls callback', (done) => {
     bookModel.paginate({}, {}, (err: Error, result: IPaginatedResult<any>) => {
       expect(err).to.be.null;
       expect(result).to.be.an.instanceOf(Object);
@@ -83,12 +86,14 @@ describe('plugin pagination', () => {
       });
     });
     it('with offset and limit', () => {
-      return bookModel.paginate({}, { offset: 30, limit: 20 }).then((result: IPaginatedResult<any>) => {
-        expect(result.items).to.have.length(20);
-        expect(result.paging.totalCount).to.equal(100);
-        expect(result.paging.limit).to.equal(20);
-        expect(result.paging.offset).to.equal(30);
-      });
+      return bookModel
+        .paginate({}, { offset: 30, limit: 20 })
+        .then((result: IPaginatedResult<any>) => {
+          expect(result.items).to.have.length(20);
+          expect(result.paging.totalCount).to.equal(100);
+          expect(result.paging.limit).to.equal(20);
+          expect(result.paging.offset).to.equal(30);
+        });
     });
     it('with zero limit', () => {
       return bookModel.paginate({}, { page: 1, limit: 0 }).then((result: IPaginatedResult<any>) => {
@@ -104,14 +109,18 @@ describe('plugin pagination', () => {
       });
     });
     it('with sort', () => {
-      return bookModel.paginate({}, { sort: { date: -1 } }).then((result: IPaginatedResult<any>) => {
-        expect(result.items[0].title).to.equal('Book #100');
-      });
+      return bookModel
+        .paginate({}, { sort: { date: -1 } })
+        .then((result: IPaginatedResult<any>) => {
+          expect(result.items[0].title).to.equal('Book #100');
+        });
     });
     it('with populate', () => {
-      return bookModel.paginate({}, { populate: 'author' }).then((result: IPaginatedResult<any>) => {
-        expect(result.items[0].author.name).to.equal('Arthur Conan Doyle');
-      });
+      return bookModel
+        .paginate({}, { populate: 'author' })
+        .then((result: IPaginatedResult<any>) => {
+          expect(result.items[0].author.name).to.equal('Arthur Conan Doyle');
+        });
     });
     describe('with lean', () => {
       it('with default leanWithId=true', () => {
@@ -122,19 +131,21 @@ describe('plugin pagination', () => {
         });
       });
       it('with leanWithId=false', () => {
-        return bookModel.paginate({}, { lean: true, leanWithId: false }).then((result: IPaginatedResult<any>) => {
-          expect(result.items[0]).to.not.be.an.instanceof((mongoose as any).Document);
-          expect(result.items[0]).to.not.have.property('id');
-        });
+        return bookModel
+          .paginate({}, { lean: true, leanWithId: false })
+          .then((result: IPaginatedResult<any>) => {
+            expect(result.items[0]).to.not.be.an.instanceof((mongoose as any).Document);
+            expect(result.items[0]).to.not.have.property('id');
+          });
       });
     });
   });
 
-  after(done => {
+  after((done) => {
     mongoose.connection.db.dropDatabase(done);
   });
 
-  after(done => {
+  after((done) => {
     mongoose.disconnect(done);
   });
 });

package/src/plugins/pagination/index.ts

@@ -1,6 +1,10 @@
 import { IPaginateOptions } from './specs/IPaginateOptions';
 
-function paginate(q: any, options: IPaginateOptions, callback: (error: Error, result: any) => void) {
+function paginate(
+  q: any,
+  options: IPaginateOptions,
+  callback: (error: Error, result: any) => void
+) {
   const optionsClean = PaginateBuilder.getOptions((paginate as any).options, options);
 
   const query = q || {};
@@ -22,14 +26,18 @@ export class PaginateBuilder {
     lean: false,
     leanWithId: true,
     limit: 10,
-    offset: 0
+    offset: 0,
   });
 
   public static getOptions(...options: IPaginateOptions[]): IPaginateOptions {
     return Object.assign({}, PaginateBuilder.defaultOptions, ...options);
   }
 
-  public static executeQueries(model: any, query: any, options: IPaginateOptions): [Promise<any[]>, Promise<number>] {
+  public static executeQueries(
+    model: any,
+    query: any,
+    options: IPaginateOptions
+  ): [Promise<any[]>, Promise<number>] {
     const { select, sort, populate, lean, leanWithId, limit, offset } = options;
     let itemsQuery: any;
 
@@ -38,20 +46,17 @@ export class PaginateBuilder {
     }
 
     if (limit > 0) {
-      itemsQuery = model
-        .find(query)
-        .select(select)
-        .sort(sort)
-        .skip(offset)
-        .limit(limit)
-        .lean(lean);
+      itemsQuery = model.find(query).select(select).sort(sort).skip(offset).limit(limit).lean(lean);
 
       if (populate) {
-        [].concat(populate).forEach(item => itemsQuery.populate(item));
+        [].concat(populate).forEach((item) => itemsQuery.populate(item));
       }
     }
 
-    return [itemsQuery && limit > 0 ? itemsQuery.exec() : Promise.resolve([]), model.countDocuments(query).exec()];
+    return [
+      itemsQuery && limit > 0 ? itemsQuery.exec() : Promise.resolve([]),
+      model.countDocuments(query).exec(),
+    ];
   }
 
   public static processResult(
@@ -62,7 +67,7 @@ export class PaginateBuilder {
     const { lean, leanWithId, limit, offset } = options;
     return new Promise((resolve, reject) => {
       Promise.all(promises).then(
-        data => {
+        (data) => {
           const items = data[0] as any[];
           const count = data[1] as number;
           const result: any = { paging: { limit, offset, totalCount: count } };
@@ -84,7 +89,7 @@ export class PaginateBuilder {
 
           resolve(result);
         },
-        error => {
+        (error) => {
           if (typeof callback === 'function') {
             return callback(error, null);
           }

package/src/utils/logger.ts

@@ -1,4 +1,11 @@
-import { ILogger, initLogger, LazyLogger, Logger, LoggerConfigs, LogLevel } from '@villedemontreal/logger';
+import {
+  ILogger,
+  initLogger,
+  LazyLogger,
+  Logger,
+  LoggerConfigs,
+  LogLevel,
+} from '@villedemontreal/logger';
 import { configs } from '../config/configs';
 
 let testingLoggerLibInitialised = false;

package/dist/src/config/configs.d.ts

@@ -1,16 +0,0 @@
-import { ILogger } from '@villedemontreal/logger';
-/**
- * Lib configs
- */
-export declare class Configs {
-    private _loggerCreator;
-    /**
-     * The Logger creator
-     */
-    get loggerCreator(): (name: string) => ILogger;
-    /**
-     * Sets the Logger creator.
-     */
-    setLoggerCreator(loggerCreator: (name: string) => ILogger): void;
-}
-export declare let configs: Configs;

package/dist/src/config/constants.d.ts

@@ -1,85 +0,0 @@
-import { IMongooseConfigs } from './mongooseConfigs';
-/**
- * Library constants
- */
-export declare class Constants {
-    /**
-     * The library root. When this library is used
-     * as a dependency in a project, the "libRoot"
-     * will be the path to the dependency folder,
-     * inside the "node_modules".
-     */
-    libRoot: string;
-    /**
-     * The app root. When this library is used
-     * as a dependency in a project, the "appRoot"
-     * will be the path to the root project!
-     */
-    appRoot: string;
-    constructor();
-    /**
-     * Base config to 'mock' a mongo server
-     */
-    get testsConfig(): IMongooseConfigs;
-    /**
-     * Mongo constants
-     */
-    get mongo(): {
-        testing: {
-            /**
-             * The "connectionString" to use for a mock
-             * Mongo server to be used instead of a real one.
-             * This option is only available on the "development"
-             * environment, or when tests are ran.
-             */
-            MOCK_CONNECTION_STRING: string;
-        };
-        /**
-         * The names of the Mongo collections used in
-         * this application.
-         */
-        collectionNames: {
-            /**
-             * Special collection that stores informations about the
-             * schema currently installed for the application.
-             */
-            APP_SCHEMA: string;
-        };
-        /**
-         * Mongo error codes
-         */
-        mongoErrorCodes: {
-            /**
-             * The code for a Mongo "duplicate key" error.
-             */
-            DUPLICATE_KEY: number;
-        };
-        /**
-         * Mongoose constants
-         */
-        mongoose: {
-            /**
-             *  Mongoose error codes
-             */
-            errorCodes: {
-                /**
-                 * The code for a Mongoose "required" error.
-                 */
-                REQUIRED_FIELD: string;
-            };
-            /**
-             *  Mongoose error kinds
-             */
-            errorKinds: {
-                OBJECT_ID: string;
-            };
-            /**
-             *  Mongoose error names
-             */
-            errorNames: {
-                CAST_ERROR: string;
-            };
-        };
-    };
-}
-export declare let constants: Constants;

package/dist/src/config/init.d.ts

@@ -1,9 +0,0 @@
-import { ILogger } from '@villedemontreal/logger';
-/**
- * Inits the library.
- */
-export declare function init(loggerCreator: (name: string) => ILogger): void;
-/**
- * checks if the library has been initialized.
- */
-export declare function isInited(): boolean;

package/dist/src/config/mongooseConfigs.d.ts

@@ -1,73 +0,0 @@
-export interface IMongooseConfigs {
-    /**
-     * The updater.mongoSchemaUpdatesDirPath
-     * is a required config.
-     */
-    updater?: {
-        /**
-         * Name of the app schema collection name to use.
-         * Useful when multiple components use the same database.
-         */
-        appSchemaCollectionName?: string;
-        /**
-         * The path where to find update files.
-         */
-        mongoSchemaUpdatesDirPath: string;
-        lockMaxAgeSeconds?: number;
-    };
-    /**
-     * @param applyUpdates Should the database be checked for missing
-     * updates and have them applied if required?
-     * Defaults to true.
-     */
-    applyUpdates?: boolean;
-    /**
-     * If no connectionString is provided, "mock" will be
-     * used by default and a temporary Mongo server will
-     * be used.
-     */
-    connectionString?: string;
-    /**
-     * The Mongoose connection options.
-     */
-    connectionOptions?: any;
-    mockServer?: {
-        /**
-         *  @param mongoServerVersion the Mongo version to use.
-         *
-         * Pass null (or undefined) to use the default version
-         * downloaded by mockServer.
-         */
-        serverVersion?: string;
-    };
-}
-/**
- * Mongoose configs with default values.
- */
-export declare class MongooseConfigs implements IMongooseConfigs {
-    /**
-     * @param applyUpdates Should the database be checked for missing
-     * updates and have them applied if required?
-     */
-    applyUpdates: boolean;
-    /**
-     * If no connectionString is provided, "mock" will be
-     * used by default and a temporary Mongo server will
-     * be used.
-     */
-    connectionString: string;
-    connectionOptions: any;
-    updater: {
-        lockMaxAgeSeconds: number;
-        mongoSchemaUpdatesDirPath: string;
-        appSchemaCollectionName: string;
-    };
-    mockServer: {
-        serverVersion: string;
-    };
-    /**
-     * Overrides default configurations using the ones passed
-     * as parameters.
-     */
-    constructor(overridingConfigs: IMongooseConfigs);
-}

package/dist/src/index.d.ts

@@ -1,6 +0,0 @@
-export * from './mongoUtils';
-export * from './config/constants';
-export { IMongooseConfigs } from './config/mongooseConfigs';
-export * from './mongoClient';
-export * from './config/init';
-export * from './plugins/pagination';

package/dist/src/mongoClient.d.ts

@@ -1,19 +0,0 @@
-import * as mongoose from 'mongoose';
-import { IMongooseConfigs } from './config/mongooseConfigs';
-/**
- * This is the entry point to use this library to manage your
- * Mongoose connections.
- *
- * It *must* be called when the application starts, before any
- * connection is made to Mongo.
- *
- * @returns the Mongoose connection to Mongo.
- */
-export declare function initMongoose(mongooseConfig: IMongooseConfigs): Promise<mongoose.Connection>;
-/**
- * Returns the Mongoose connection.
- *
- * Will throw an error if Mongo haass not been initialized
- * using the "initMongo()" function.
- */
-export declare function getMongooseConnection(): mongoose.Connection;

package/dist/src/mongoUpdater.d.ts

@@ -1,103 +0,0 @@
-import * as MongoDb from 'mongodb';
-/**
- * Mongo updater
- * Manages the updates of the mongo schemas
- */
-export interface IMongoUpdater {
-    /**
-     * Validates that the application has been installed.
-     * This involves creating a special "appSchema" collection
-     * and document to track the application version and being able
-     * to update its schemas and documents...
-     */
-    checkInstallation(): Promise<void>;
-    /**
-     * Checks if the application needs update or not. Installs the updates
-     * if so.
-     */
-    checkUpdates(): Promise<void>;
-    /**
-     * Locks the appSchema document.
-     *
-     * @returns true if the lock has been acquired succesfully
-     * or false if the document was already locked.
-     */
-    lockAppSchemaDocument(): Promise<boolean>;
-    /**
-     * Unlocks the appSchema document.
-     *
-     * @returns true if the lock has been removed succesfully
-     * or false if the document was not locked.
-     */
-    unlockAppSchemaDocument(): Promise<boolean>;
-    /**
-     * Updates the app schema version stored in mongo database
-     */
-    updateAppSchemaVersion(currentVersion: string, newVersion: string): Promise<void>;
-    /**
-     * Installs the appSchema collection.
-     */
-    installAppSchemaCollection(): Promise<any>;
-    /**
-     * Gets a list of available app schema update files.
-     */
-    getAppSchemaUpdateFiles(currentVersion: string, newVersion: string): Promise<string[]>;
-    /**
-     * Updates the app schema
-     */
-    applyAppSchemaUpdates(currentVersion: string, newVersion: string): Promise<any>;
-    /**
-     * Gets the appSchema collection
-     */
-    getAppSchemaCollection(): Promise<MongoDb.Collection>;
-    /**
-     * Gets the current version from the appSchema document.
-     */
-    getAppSchemaVersion(): Promise<string>;
-}
-export interface ISchemeInfo {
-    version: string;
-    lock: boolean;
-    lockTimestamp: number;
-}
-export declare class MongoUpdater implements IMongoUpdater {
-    private mongoDb;
-    /**
-     * The *relative* path to the directory where the
-     * update files are.
-     */
-    private mongoSchemaUpdatesDirPath;
-    private lockMaxAgeSeconds;
-    private appSchemaCollectionName;
-    constructor(mongoDb: MongoDb.Db, 
-    /**
-     * The *relative* path to the directory where the
-     * update files are.
-     */
-    mongoSchemaUpdatesDirPath: string, lockMaxAgeSeconds: number, appSchemaCollectionName: string);
-    installAppSchemaCollection(): Promise<any>;
-    updateAppSchemaVersion(currentVersion: string, newVersion: string): Promise<void>;
-    getAppSchemaUpdateFiles(currentAppSchemaVersion: string, targetAppSchemaVersion: string): Promise<string[]>;
-    applyAppSchemaUpdates(currentVersion: string, newVersion: string): Promise<void>;
-    getAppSchemaCollection(): Promise<MongoDb.Collection>;
-    getAppSchemaVersion(): Promise<string>;
-    /**
-     * Tries to get the lock to modify Mongo's schemas.
-     *
-     * If a lock already exists, checks if it is too old.
-     * If too old, will create a new one... This is to prevents
-     * situations where a lock would have been taken by an app
-     * but that app *crashed* while the lock was on. We don't want
-     * suck lock to be active forever...
-     *
-     */
-    lockAppSchemaDocument(): Promise<boolean>;
-    unlockAppSchemaDocument(): Promise<boolean>;
-    checkInstallation(): Promise<void>;
-    checkUpdates: () => Promise<void>;
-    protected getAppSchemaFilesDirPath(): string;
-    /**
-     * Finds the latest Mongo update file version.
-     */
-    protected findMongoAppSchemaTargetVersion(): string;
-}

package/dist/src/mongoUpdater.test.d.ts

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

package/dist/src/mongoUtils.d.ts

@@ -1,68 +0,0 @@
-import { ApiErrorAndInfo } from '@villedemontreal/general-utils';
-import * as mocha from 'mocha';
-import { MongoMemoryReplSet, MongoMemoryServer } from 'mongodb-memory-server-core';
-import * as mongoose from 'mongoose';
-/**
- * Mongo utilities
- */
-export declare class MongoUtils {
-    private mongoMemServer;
-    private useReplSet;
-    private mockgosseMockedFlag;
-    /**
-     * Mocks the Mongo databases created through Mongoose.
-     *
-     * IMPORTANT!!
-     * For the "mochaInstance" parameter to be the proper
-     * one, this function must be called from a *regular function* in a
-     * test file, not from an *arrow function*! For more informations,
-     * see : https://github.com/mochajs/mocha/issues/2018
-     *
-     * Note that, currently, once this mocking is in place,
-     * it can't be removed. You should only call this function
-     * during testing!
-     *
-     * If Mongoose is already mocked, the function does nothing.
-     *
-     * @param mocha from a Mocha test file, pass "this" as the value
-     * for this parameter or "null" from elsewhere.
-     *
-     * @param mongoServerVersion the Mongo version to use.
-     * Pass null (or undefined) to use the default version
-     * downloaded by mongodb-memory-server.
-     */
-    mockMongoose(mochaInstance: mocha.Context, mongoServerVersion: string, useReplSet?: boolean): Promise<MongoMemoryServer | MongoMemoryReplSet>;
-    /**
-     * Drop all mocked Mongo databases.
-     *
-     */
-    dropMockedDatabases(): Promise<void>;
-    getMockedServerPort(): Promise<number>;
-    /**
-     * Validates if an object is a Mongoose
-     * error.
-     */
-    isMongooseError(obj: any): boolean;
-    /**
-     * Validates if an object is a plain
-     * Mongo error.
-     */
-    isPlainMongoError(errorObject: any): boolean;
-    /**
-     * Creates an Api eror from an error thrown
-     * by Mongoose.
-     *
-     * If the specified error is not a Mongo/Mongoose error, it
-     * will be returned as is.
-     *
-     * @param error the Mongo/Mongoose error object
-     * @param publicMessage a public message to be used in the
-     * generated error. Fopr example : "The user is invalid".
-     */
-    convertMongoOrMongooseErrorToApiError(err: any, publicMessage: string): ApiErrorAndInfo | any;
-    /**
-     * Converts a Mongoose Document to a plain Pojo.
-     */
-    convertMongooseDocumentToPlainObject<T>(document: T & mongoose.Document): T;
-}
-export declare let mongoUtils: MongoUtils;

package/dist/src/plugins/pagination/index.d.ts

@@ -1,11 +0,0 @@
-import { IPaginateOptions } from './specs/IPaginateOptions';
-/**
- * @param {Schema} schema
- */
-export declare function mongoosePaginate(schema: any): void;
-export declare class PaginateBuilder {
-    private static readonly defaultOptions;
-    static getOptions(...options: IPaginateOptions[]): IPaginateOptions;
-    static executeQueries(model: any, query: any, options: IPaginateOptions): [Promise<any[]>, Promise<number>];
-    static processResult(promises: any[], options: IPaginateOptions, callback: (error: Error, result: any) => void): Promise<any>;
-}

package/dist/src/plugins/pagination/index.test.d.ts

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

package/dist/src/plugins/pagination/specs/IPaginateOptions.d.ts

@@ -1,51 +0,0 @@
-export interface IPaginateOptions {
-    /**
-     * Fields to return (by default returns all fields)
-     * http://mongoosejs.com/docs/api.html#query_Query-select
-     * @type {string}
-     * @memberof IPaginateOptions
-     */
-    select?: string;
-    /**
-     * Sort order
-     * http://mongoosejs.com/docs/api.html#query_Query-sort
-     * @type {*}
-     * @memberof IPaginateOptions
-     */
-    sort?: any;
-    /**
-     * Paths which should be populated with other documents.
-     * http://mongoosejs.com/docs/api.html#query_Query-populate
-     * @type {string}
-     * @memberof IPaginateOptions
-     */
-    populate?: string;
-    /**
-     * Should return plain javascript objects instead of Mongoose documents?
-     * default false
-     * @type {boolean}
-     * @memberof IPaginateOptions
-     */
-    lean?: boolean;
-    /**
-     * If lean and leanWithId are true, adds id field with string representation of _id to every document
-     * default true
-     * @type {boolean}
-     * @memberof IPaginateOptions
-     */
-    leanWithId?: boolean;
-    /**
-     * Use offset to set skip position
-     * default 0
-     * @type {number}
-     * @memberof IPaginateOptions
-     */
-    offset?: number;
-    /**
-     * limit the items returned
-     * default 10
-     * @type {number}
-     * @memberof IPaginateOptions
-     */
-    limit?: number;
-}