@villedemontreal/mongo 6.7.0 → 6.7.3

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;