c2-mongoose 2.1.13 → 2.1.17

package/src/flow/SearchFlow.ts

@@ -1,238 +1,238 @@
-import moment from "moment"
-import mongoose from "mongoose"
-import { dbCollation } from "../configuration/Environment"
-import { Pagination, SearchResponse } from "../types/SearchResponse"
-import { isEmpty, isNotEmpty } from "../utils/Utils"
-
-abstract class SearchFlow {
-  searchText: string
-  order: string
-  orderBy: string
-  page: number
-  limit: number
-  select: string
-  populate: any
-  filters: any
-
-  constructor(params: any) {
-    this.searchText = params.searchText || ""
-    this.order = params.order || "asc"
-    this.orderBy = params.orderBy || "_id"
-    this.select = params.select
-    this.populate = params.populate
-    this.page = params.page || undefined
-    this.limit = params.limit || 25
-    this.buildPopulate()
-  }
-
-  public buildPopulate(): any {
-    if (isEmpty(this.populate)) {
-      return
-    }
-
-    var propertiesArray = this.populate.toString().split(',')
-    var populates = [] as any
-    for (var property of propertiesArray) {
-      let [first, ...rest] = property.split('.')
-      let nested = rest.join('.')
-      populates.push(this.buildPath(first, nested))
-    }
-
-    this.populate = populates
-  }
-
-  public buildPath(target: string, nested: string = "") {
-    var populate = {} as any
-    populate.path = target
-    if (isNotEmpty(nested)) {
-      let [first, ...rest] = nested.split('.')
-      let nested2 = rest.join('.')
-      populate.populate = this.buildPath(first, nested2)
-    }
-    return populate
-  }
-
-  public buildOrdenation() {
-    let order = {} as any
-    this.orderBy = this.orderBy || "_id"
-    order[this.orderBy] = this.order === "desc" ? -1 : 1
-    return order
-  }
-
-  private isPageable = () => {
-    if (isEmpty(this.page)) {
-      this.page = 1
-    }
-
-    if (this.page >= 0) {
-      return true
-    }
-
-    return false
-  }
-
-  public diacriticSensitiveRegex(string: string = ""): string {
-    return string
-      .replace(/[a|á|à|ä|â|A|Á|Â|Ã|Ä]/g, '[a,á,à,ä,â,A,Á,Â,Ã,Ä]')
-      .replace(/[e|é|ë|è|E|É|Ë|È]/g, '[e,é,ë,è,E,É,Ë,È]')
-      .replace(/[i|í|ï|ì|I|Í|Ï|Ì]/g, '[i,í,ï,ì,I,Í,Ï,Ì]')
-      .replace(/[o|ó|ö|ò|õ|O|Ó|Ö|Ô|Õ]/g, '[o,ó,ö,ò,õ,O,Ó,Ö,Ô,Õ]')
-      .replace(/[u|ü|ú|ù|U|Ú|Ü|Ù]/g, '[u,ü,ú,ù,U,Ú,Ü,Ù]')
-      .replace(/[ç|Ç|c|C]/g, '[c,C,ç,Ç]')
-  }
-
-  public async search(model: mongoose.Model<any>): Promise<SearchResponse<any>> {
-    if (this.isPageable()) {
-      return await this.searchPageable(model)
-    }
-
-    return await this.searchNoPageable(model)
-  }
-
-  private searchPageable = async (model: mongoose.Model<any>): Promise<SearchResponse<any>> => {
-    const sort = this.buildOrdenation()
-    var items = await model
-      .find(this.filters, this.select)
-      .populate(this.populate)
-      .skip((this.page - 1) * this.limit)
-      .limit(this.limit)
-      .sort(sort)
-      .collation({
-        locale: dbCollation || "pt"
-      }) as []
-
-    return this.result(model, items)
-  }
-
-  private async searchNoPageable(model: mongoose.Model<any>): Promise<SearchResponse<any>> {
-    const sort = this.buildOrdenation()
-    var items = await model
-      .find(this.filters, this.select)
-      .populate(this.populate)
-      .sort(sort)
-      .collation({
-        locale: dbCollation || "pt"
-      }) as []
-
-    return this.result(model, items)
-  }
-
-  private async result(model: mongoose.Model<any>, items: []): Promise<SearchResponse<any>> {
-    var total = await this.count(model)
-
-    var paging: Pagination = {}
-    paging.total = total
-    paging.page = this.page
-    paging.limit = this.limit
-
-    var searchResponse: SearchResponse<any> = {}
-    searchResponse.items = items
-    searchResponse.paging = paging
-
-    return searchResponse
-  }
-
-  public async count(model: mongoose.Model<any>): Promise<number> {
-    return await model.countDocuments(this.filters).exec()
-  }
-
-  public async findOne(repository: mongoose.Model<any>, model: any, params: any = {}) {
-    return await repository.findOne(model)
-      .sort(params.sort)
-      .select(params.select)
-      .populate(params.populate)
-  }
-
-  public async sumBy(model: mongoose.Model<any>, _sum: any, _by: any): Promise<any[]> {
-    const ret = await model.aggregate(
-      [
-        {
-          '$match': this.filters
-        },
-        {
-          $group: {
-            _id: _by,
-            totalValue: { "$sum": _sum },
-            count: { "$sum": 1 }
-          }
-        }
-      ]
-    )
-    return ret
-  }
-
-  public buildDefaultFilters(objectSearch: any) {
-    let filters = { $and: [] } as any
-    Object.entries(objectSearch.model).forEach(([key, value]) => {
-      if (isNotEmpty(value)) {
-        let condition = {} as any
-        if (['order', 'orderBy', 'properties', 'populate', 'page', 'limit', 'model', 'select', 'searchText', 'isPageable', 'searchPageable'].includes(key)) {
-          return
-        }
-
-        if (key.endsWith('DateRange') || key.endsWith('DateTimeRange') ) {
-          var fieldName = key.replace('Range', '')
-          var values = value as any
-          if (isNotEmpty(values[0])) {
-            var momentValue = moment(values[0])
-            condition[fieldName] = {
-              ...condition[fieldName],
-              $gte: momentValue.toDate()
-            }
-          }
-
-          if (isNotEmpty(values[1])) {
-            var momentValue = moment(values[1])
-            condition[fieldName] = {
-              ...condition[fieldName],
-              $lte: momentValue.toDate()
-            }
-          }
-          filters.$and.push(condition)
-        } else if (key.endsWith('Like')) {
-          var fieldName = key.replace('Like', '')
-          condition[fieldName] = { $regex: value as any, $options: 'i' }
-          filters.$and.push(condition)
-        } else {
-          if (!Array.isArray(value)) {
-            condition[key] = value
-          } else {
-            condition[key] = { $in: value }
-          }
-          filters.$and.push(condition)
-        }
-      }
-    })
-
-
-    // if (isNotEmpty(objectSearch.model)) {
-    //   this.addFilterModel(objectSearch.model, filters)
-    // }
-
-    if (filters.$and.length === 0)
-      delete filters['$and']
-
-    return filters
-  }
-
-  public addFilterModel(model: any, filters: any) {
-    Object.entries(model).forEach(([key, value]) => {
-      if (key.endsWith('DateRange')) {
-        return
-      }
-      if (key.endsWith('Like')) {
-        return
-      }
-      if (['order', 'orderBy', 'properties', 'populate', 'page', 'limit', 'model', 'select', 'searchText', 'isPageable', 'searchPageable'].includes(key)) {
-        return
-      }
-      if (isNotEmpty(value)) {
-        let condition = {} as any
-        condition[key] = value
-        filters.$and.push(condition)
-      }
-    })
-  }
-}
-
+import moment from "moment"
+import mongoose from "mongoose"
+import { dbCollation } from "../configuration/Environment"
+import { Pagination, SearchResponse } from "../types/SearchResponse"
+import { isEmpty, isNotEmpty } from "../utils/Utils"
+
+abstract class SearchFlow {
+  searchText: string
+  order: string
+  orderBy: string
+  page: number
+  limit: number
+  select: string
+  populate: any
+  filters: any
+
+  constructor(params: any) {
+    this.searchText = params.searchText || ""
+    this.order = params.order || "asc"
+    this.orderBy = params.orderBy || "_id"
+    this.select = params.select
+    this.populate = params.populate
+    this.page = params.page || undefined
+    this.limit = params.limit || 25
+    this.buildPopulate()
+  }
+
+  public buildPopulate(): any {
+    if (isEmpty(this.populate)) {
+      return
+    }
+
+    var propertiesArray = this.populate.toString().split(',')
+    var populates = [] as any
+    for (var property of propertiesArray) {
+      let [first, ...rest] = property.split('.')
+      let nested = rest.join('.')
+      populates.push(this.buildPath(first, nested))
+    }
+
+    this.populate = populates
+  }
+
+  public buildPath(target: string, nested: string = "") {
+    var populate = {} as any
+    populate.path = target
+    if (isNotEmpty(nested)) {
+      let [first, ...rest] = nested.split('.')
+      let nested2 = rest.join('.')
+      populate.populate = this.buildPath(first, nested2)
+    }
+    return populate
+  }
+
+  public buildOrdenation() {
+    let order = {} as any
+    this.orderBy = this.orderBy || "_id"
+    order[this.orderBy] = this.order === "desc" ? -1 : 1
+    return order
+  }
+
+  private isPageable = () => {
+    if (isEmpty(this.page)) {
+      this.page = 1
+    }
+
+    if (this.page >= 0) {
+      return true
+    }
+
+    return false
+  }
+
+  public diacriticSensitiveRegex(string: string = ""): string {
+    return string
+      .replace(/[a|á|à|ä|â|A|Á|Â|Ã|Ä]/g, '[a,á,à,ä,â,A,Á,Â,Ã,Ä]')
+      .replace(/[e|é|ë|è|E|É|Ë|È]/g, '[e,é,ë,è,E,É,Ë,È]')
+      .replace(/[i|í|ï|ì|I|Í|Ï|Ì]/g, '[i,í,ï,ì,I,Í,Ï,Ì]')
+      .replace(/[o|ó|ö|ò|õ|O|Ó|Ö|Ô|Õ]/g, '[o,ó,ö,ò,õ,O,Ó,Ö,Ô,Õ]')
+      .replace(/[u|ü|ú|ù|U|Ú|Ü|Ù]/g, '[u,ü,ú,ù,U,Ú,Ü,Ù]')
+      .replace(/[ç|Ç|c|C]/g, '[c,C,ç,Ç]')
+  }
+
+  public async search(model: mongoose.Model<any>): Promise<SearchResponse<any>> {
+    if (this.isPageable()) {
+      return await this.searchPageable(model)
+    }
+
+    return await this.searchNoPageable(model)
+  }
+
+  private searchPageable = async (model: mongoose.Model<any>): Promise<SearchResponse<any>> => {
+    const sort = this.buildOrdenation()
+    var items = await model
+      .find(this.filters, this.select)
+      .populate(this.populate)
+      .skip((this.page - 1) * this.limit)
+      .limit(this.limit)
+      .sort(sort)
+      .collation({
+        locale: dbCollation || "pt"
+      }) as []
+
+    return this.result(model, items)
+  }
+
+  private async searchNoPageable(model: mongoose.Model<any>): Promise<SearchResponse<any>> {
+    const sort = this.buildOrdenation()
+    var items = await model
+      .find(this.filters, this.select)
+      .populate(this.populate)
+      .sort(sort)
+      .collation({
+        locale: dbCollation || "pt"
+      }) as []
+
+    return this.result(model, items)
+  }
+
+  private async result(model: mongoose.Model<any>, items: []): Promise<SearchResponse<any>> {
+    var total = await this.count(model)
+
+    var paging: Pagination = {}
+    paging.total = total
+    paging.page = this.page
+    paging.limit = this.limit
+
+    var searchResponse: SearchResponse<any> = {}
+    searchResponse.items = items
+    searchResponse.paging = paging
+
+    return searchResponse
+  }
+
+  public async count(model: mongoose.Model<any>): Promise<number> {
+    return await model.countDocuments(this.filters).exec()
+  }
+
+  public async findOne(repository: mongoose.Model<any>, model: any, params: any = {}) {
+    return await repository.findOne(model)
+      .sort(params.sort)
+      .select(params.select)
+      .populate(params.populate)
+  }
+
+  public async sumBy(model: mongoose.Model<any>, _sum: any, _by: any): Promise<any[]> {
+    const ret = await model.aggregate(
+      [
+        {
+          '$match': this.filters
+        },
+        {
+          $group: {
+            _id: _by,
+            totalValue: { "$sum": _sum },
+            count: { "$sum": 1 }
+          }
+        }
+      ]
+    )
+    return ret
+  }
+
+  public buildDefaultFilters(objectSearch: any) {
+    let filters = { $and: [] } as any
+    Object.entries(objectSearch.model).forEach(([key, value]) => {
+      if (isNotEmpty(value)) {
+        let condition = {} as any
+        if (['order', 'orderBy', 'properties', 'populate', 'page', 'limit', 'model', 'select', 'searchText', 'isPageable', 'searchPageable'].includes(key)) {
+          return
+        }
+
+        if (key.endsWith('DateRange') || key.endsWith('DateTimeRange')) {
+          var fieldName = key.replace('Range', '')
+          var values = value as any
+          if (isNotEmpty(values[0])) {
+            var momentValue = moment(values[0])
+            condition[fieldName] = {
+              ...condition[fieldName],
+              $gte: momentValue.toDate()
+            }
+          }
+
+          if (isNotEmpty(values[1])) {
+            var momentValue = moment(values[1])
+            condition[fieldName] = {
+              ...condition[fieldName],
+              $lte: momentValue.toDate().setHours(23, 59, 59)
+            }
+          }
+          filters.$and.push(condition)
+        } else if (key.endsWith('Like')) {
+          var fieldName = key.replace('Like', '')
+          condition[fieldName] = { $regex: value as any, $options: 'i' }
+          filters.$and.push(condition)
+        } else {
+          if (!Array.isArray(value)) {
+            condition[key] = value
+          } else {
+            condition[key] = { $in: value }
+          }
+          filters.$and.push(condition)
+        }
+      }
+    })
+
+
+    // if (isNotEmpty(objectSearch.model)) {
+    //   this.addFilterModel(objectSearch.model, filters)
+    // }
+
+    if (filters.$and.length === 0)
+      delete filters['$and']
+
+    return filters
+  }
+
+  public addFilterModel(model: any, filters: any) {
+    Object.entries(model).forEach(([key, value]) => {
+      if (key.endsWith('DateRange')) {
+        return
+      }
+      if (key.endsWith('Like')) {
+        return
+      }
+      if (['order', 'orderBy', 'properties', 'populate', 'page', 'limit', 'model', 'select', 'searchText', 'isPageable', 'searchPageable'].includes(key)) {
+        return
+      }
+      if (isNotEmpty(value)) {
+        let condition = {} as any
+        condition[key] = value
+        filters.$and.push(condition)
+      }
+    })
+  }
+}
+
 export default SearchFlow

package/src/index.ts

@@ -1,5 +1,5 @@
-import CrudFlow from "./flow/CrudFlow"
-import SearchFlow from "./flow/SearchFlow"
-import { Pagination, SearchResponse } from "./types/SearchResponse"
-
-export { CrudFlow, SearchFlow, SearchResponse, Pagination }
+import CrudFlow from "./flow/CrudFlow"
+import SearchFlow from "./flow/SearchFlow"
+import { Pagination, SearchResponse } from "./types/SearchResponse"
+
+export { CrudFlow, SearchFlow, SearchResponse, Pagination }

package/src/types/SearchResponse.d.ts

@@ -1,10 +1,10 @@
-export declare interface SearchResponse<T> {
-    paging?: Pagination,
-    items?: T[]
-}
-
-export declare interface Pagination {
-    total?: number,
-    page?: number,
-    limit?: number
+export declare interface SearchResponse<T> {
+    paging?: Pagination,
+    items?: T[]
+}
+
+export declare interface Pagination {
+    total?: number,
+    page?: number,
+    limit?: number
 }

package/src/utils/Utils.ts

@@ -1,57 +1,57 @@
-export const isNotEmpty = (obj: any) => {
-    return !isEmpty(obj)
-}
-
-export const isEmpty = (obj: any) => {
-    if (!obj) {
-        return true
-    }
-
-    if (Array.isArray(obj)) {
-        if (obj.length == 0) {
-            return true
-        }
-    }
-
-    if (obj === "") {
-        return true
-    }
-
-    return false
-}
-
-export const isIterable = (input: any) => {
-    if (input === null || input === undefined) {
-        return false
-    }
-
-    if ('string' === typeof input) {
-        return false
-    }
-
-    return typeof input[Symbol.iterator] === 'function'
-}
-
-export const isNotIterable = (input: any) => {
-    return !isIterable(input)
-}
-
-export const compareAsc = (a: any, b: any) => {
-    if (a._id < b._id) {
-        return -1;
-    }
-    if (a._id > b._id) {
-        return 1;
-    }
-    return 0;
-}
-
-export const compareDesc = (a: any, b: any) => {
-    if (a._id > b._id) {
-        return -1;
-    }
-    if (a._id < b._id) {
-        return 1;
-    }
-    return 0;
+export const isNotEmpty = (obj: any) => {
+    return !isEmpty(obj)
+}
+
+export const isEmpty = (obj: any) => {
+    if (!obj) {
+        return true
+    }
+
+    if (Array.isArray(obj)) {
+        if (obj.length == 0) {
+            return true
+        }
+    }
+
+    if (obj === "") {
+        return true
+    }
+
+    return false
+}
+
+export const isIterable = (input: any) => {
+    if (input === null || input === undefined) {
+        return false
+    }
+
+    if ('string' === typeof input) {
+        return false
+    }
+
+    return typeof input[Symbol.iterator] === 'function'
+}
+
+export const isNotIterable = (input: any) => {
+    return !isIterable(input)
+}
+
+export const compareAsc = (a: any, b: any) => {
+    if (a._id < b._id) {
+        return -1;
+    }
+    if (a._id > b._id) {
+        return 1;
+    }
+    return 0;
+}
+
+export const compareDesc = (a: any, b: any) => {
+    if (a._id > b._id) {
+        return -1;
+    }
+    if (a._id < b._id) {
+        return 1;
+    }
+    return 0;
 }

package/tsconfig.json

@@ -1,12 +1,12 @@
-{
-  "compilerOptions": {
-    "declaration": true,
-    "declarationDir": "./dist",
-    "outDir": "./dist",
-    "target": "es5",
-    "module": "commonjs",
-    "strict": true,
-    "esModuleInterop": true
-  },
-  "include": ["src/**/*"]
-}
+{
+  "compilerOptions": {
+    "declaration": true,
+    "declarationDir": "./dist",
+    "outDir": "./dist",
+    "target": "es5",
+    "module": "commonjs",
+    "strict": true,
+    "esModuleInterop": true
+  },
+  "include": ["src/**/*"]
+}

package/dist/model/Search.d.ts

@@ -1,26 +0,0 @@
-import mongoose from "mongoose";
-declare abstract class Search {
-    searchText: string;
-    order: string;
-    orderBy: string;
-    page: number;
-    limit: number;
-    select: string;
-    populate: string | [] | any;
-    filters: any;
-    constructor(params: any);
-    buildPopulate: () => any;
-    buildPath: (target: string, nested?: string) => any;
-    buildOrdenation: () => any;
-    private isPageable;
-    diacriticSensitiveRegex: (string?: string) => string;
-    search: (model: mongoose.Model<any>) => Promise<SearchResponse<any>>;
-    private searchPageable;
-    private searchNoPageable;
-    private result;
-    count: (model: mongoose.Model<any>) => Promise<number>;
-    sumBy: (model: mongoose.Model<any>, _sum: any, _by: any) => Promise<any[]>;
-    buildDefaultFilters: (objectSearch: any) => any;
-    addFilterModel: (model: any, filters: any) => void;
-}
-export default Search;