c2-mongoose 2.0.1 → 2.0.3

package/dist/flow/CrudFlow.d.ts

@@ -0,0 +1,13 @@
+import mongoose from "mongoose";
+import SearchFlow from "./SearchFlow";
+declare class CrudFlow<D> extends SearchFlow {
+    private repository;
+    constructor(repository: mongoose.Model<any>, model?: any);
+    create: (data: any, session?: any) => Promise<any[]>;
+    delete: (id: string, session?: any) => Promise<void>;
+    update: (id: string, data: D, session?: any) => Promise<D>;
+    find: (search: SearchFlow) => Promise<SearchResponse<D>>;
+    getOne: (model: D, sort?: undefined) => Promise<D>;
+    get: (id: string, pop?: string, sel?: string) => Promise<D>;
+}
+export default CrudFlow;

package/dist/flow/CrudFlow.js

@@ -0,0 +1,143 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var SearchFlow_1 = __importDefault(require("./SearchFlow"));
+var CrudFlow = /** @class */ (function (_super) {
+    __extends(CrudFlow, _super);
+    function CrudFlow(repository, model) {
+        if (model === void 0) { model = {}; }
+        var _this = _super.call(this, model) || this;
+        _this.create = function (data, session) {
+            if (session === void 0) { session = undefined; }
+            return __awaiter(_this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, this.repository.create([data], { session: session })];
+                        case 1: return [2 /*return*/, _a.sent()];
+                    }
+                });
+            });
+        };
+        _this.delete = function (id, session) {
+            if (session === void 0) { session = undefined; }
+            return __awaiter(_this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, this.repository.findByIdAndRemove(id, { session: session })];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        _this.update = function (id, data, session) {
+            if (session === void 0) { session = undefined; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var dataAfter;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, this.repository.findByIdAndUpdate(id, { $set: data }, { returnDocument: 'after', session: session })];
+                        case 1:
+                            dataAfter = _a.sent();
+                            return [2 /*return*/, dataAfter];
+                    }
+                });
+            });
+        };
+        _this.find = function (search) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, search.search(this.repository)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        _this.getOne = function (model, sort) {
+            if (sort === void 0) { sort = undefined; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var data;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, _super.prototype.findOne.call(this, this.repository, model, sort)];
+                        case 1:
+                            data = _a.sent();
+                            return [2 /*return*/, data];
+                    }
+                });
+            });
+        };
+        _this.get = function (id, pop, sel) {
+            if (pop === void 0) { pop = ""; }
+            if (sel === void 0) { sel = ""; }
+            return __awaiter(_this, void 0, void 0, function () {
+                var data;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, this.repository.findById(id).populate(pop).select(sel)];
+                        case 1:
+                            data = _a.sent();
+                            return [2 /*return*/, data];
+                    }
+                });
+            });
+        };
+        _this.repository = repository;
+        return _this;
+    }
+    return CrudFlow;
+}(SearchFlow_1.default));
+exports.default = CrudFlow;

package/dist/flow/SearchFlow.d.ts

@@ -0,0 +1,27 @@
+import mongoose from "mongoose";
+declare abstract class SearchFlow {
+    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>;
+    findOne(repository: mongoose.Model<any>, model: any, sort?: undefined): Promise<any>;
+    sumBy: (model: mongoose.Model<any>, _sum: any, _by: any) => Promise<any[]>;
+    buildDefaultFilters: (objectSearch: any) => any;
+    addFilterModel: (model: any, filters: any) => void;
+}
+export default SearchFlow;

package/dist/flow/SearchFlow.js

@@ -0,0 +1,277 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Environment_1 = require("../configuration/Environment");
+var Utils_1 = require("../utils/Utils");
+var SearchFlow = /** @class */ (function () {
+    function SearchFlow(params) {
+        var _this = this;
+        this.buildPopulate = function () {
+            if ((0, Utils_1.isEmpty)(_this.populate)) {
+                return;
+            }
+            var propertiesArray = _this.populate.split(',');
+            var populates = [];
+            for (var _i = 0, propertiesArray_1 = propertiesArray; _i < propertiesArray_1.length; _i++) {
+                var property = propertiesArray_1[_i];
+                var _a = property.split('.'), first = _a[0], rest = _a.slice(1);
+                var nested = rest.join('.');
+                populates.push(_this.buildPath(first, nested));
+            }
+            _this.populate = populates;
+        };
+        this.buildPath = function (target, nested) {
+            if (nested === void 0) { nested = ""; }
+            var populate = {};
+            populate.path = target;
+            if ((0, Utils_1.isNotEmpty)(nested)) {
+                var _a = nested.split('.'), first = _a[0], rest = _a.slice(1);
+                var nested2 = rest.join('.');
+                populate.populate = _this.buildPath(first, nested2);
+            }
+            return populate;
+        };
+        this.buildOrdenation = function () {
+            var order = {};
+            _this.orderBy = _this.orderBy || "_id";
+            order[_this.orderBy] = _this.order === "desc" ? -1 : 1;
+            return order;
+        };
+        this.isPageable = function () {
+            if ((0, Utils_1.isEmpty)(_this.page)) {
+                _this.page = 1;
+            }
+            if (_this.page >= 0) {
+                return true;
+            }
+            return false;
+        };
+        this.diacriticSensitiveRegex = function (string) {
+            if (string === void 0) { 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,ç,Ç]');
+        };
+        this.search = function (model) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.isPageable()) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.searchPageable(model)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2: return [4 /*yield*/, this.searchNoPageable(model)];
+                    case 3: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.searchPageable = function (model) { return __awaiter(_this, void 0, void 0, function () {
+            var sort, items;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        sort = this.buildOrdenation();
+                        return [4 /*yield*/, model
+                                .find(this.filters, this.select)
+                                .populate(this.populate)
+                                .skip((this.page - 1) * this.limit)
+                                .limit(this.limit)
+                                .sort(sort)
+                                .collation({
+                                locale: Environment_1.dbCollation || "pt"
+                            })];
+                    case 1:
+                        items = _a.sent();
+                        return [2 /*return*/, this.result(model, items)];
+                }
+            });
+        }); };
+        this.searchNoPageable = function (model) { return __awaiter(_this, void 0, void 0, function () {
+            var sort, items;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        sort = this.buildOrdenation();
+                        return [4 /*yield*/, model
+                                .find(this.filters, this.select)
+                                .populate(this.populate)
+                                .sort(sort)
+                                .collation({
+                                locale: Environment_1.dbCollation || "pt"
+                            })];
+                    case 1:
+                        items = _a.sent();
+                        return [2 /*return*/, this.result(model, items)];
+                }
+            });
+        }); };
+        this.result = function (model, items) { return __awaiter(_this, void 0, void 0, function () {
+            var total, paging, searchResponse;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.count(model)];
+                    case 1:
+                        total = _a.sent();
+                        paging = {};
+                        paging.total = total;
+                        paging.page = this.page;
+                        paging.limit = this.limit;
+                        searchResponse = {};
+                        searchResponse.items = items;
+                        searchResponse.paging = paging;
+                        return [2 /*return*/, searchResponse];
+                }
+            });
+        }); };
+        this.count = function (model) { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, model.countDocuments(this.filters).exec()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        }); };
+        this.sumBy = function (model, _sum, _by) { return __awaiter(_this, void 0, void 0, function () {
+            var ret;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, model.aggregate([
+                            {
+                                '$match': this.filters
+                            },
+                            {
+                                $group: {
+                                    _id: _by,
+                                    totalValue: { "$sum": _sum },
+                                    count: { "$sum": 1 }
+                                }
+                            }
+                        ])];
+                    case 1:
+                        ret = _a.sent();
+                        return [2 /*return*/, ret];
+                }
+            });
+        }); };
+        this.buildDefaultFilters = function (objectSearch) {
+            var filters = { $and: [] };
+            Object.entries(objectSearch).forEach(function (_a) {
+                var key = _a[0], value = _a[1];
+                if ((0, Utils_1.isNotEmpty)(value)) {
+                    var condition = {};
+                    if (['order', 'orderBy', 'properties', 'populate', 'page', 'limit', 'model', 'searchText'].includes(key)) {
+                        return;
+                    }
+                    if (key.endsWith('DateRange')) {
+                        var keyAux = key.replace('Range', '');
+                        var values = value;
+                        if ((0, Utils_1.isNotEmpty)(values[0])) {
+                            condition[keyAux] = __assign(__assign({}, condition[keyAux]), { $gte: new Date(values[0]) });
+                        }
+                        if ((0, Utils_1.isNotEmpty)(values[1])) {
+                            condition[keyAux] = __assign(__assign({}, condition[keyAux]), { $lte: new Date(values[1]) });
+                        }
+                    }
+                    else {
+                        if (!Array.isArray(value)) {
+                            condition[key] = value;
+                        }
+                        else {
+                            condition[key] = { $in: value };
+                        }
+                    }
+                    if ((0, Utils_1.isNotEmpty)(condition)) {
+                        filters.$and.push(condition);
+                    }
+                }
+            });
+            if ((0, Utils_1.isNotEmpty)(objectSearch.model)) {
+                _this.addFilterModel(objectSearch.model, filters);
+            }
+            if (filters.$and.length === 0)
+                delete filters['$and'];
+            return filters;
+        };
+        this.addFilterModel = function (model, filters) {
+            Object.entries(model).forEach(function (_a) {
+                var key = _a[0], value = _a[1];
+                if ((0, Utils_1.isNotEmpty)(value)) {
+                    var condition = {};
+                    condition[key] = value;
+                    filters.$and.push(condition);
+                }
+            });
+        };
+        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();
+    }
+    SearchFlow.prototype.findOne = function (repository, model, sort) {
+        if (sort === void 0) { sort = undefined; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, repository.findOne(model)
+                            .sort(sort)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return SearchFlow;
+}());
+exports.default = SearchFlow;

package/dist/index.d.ts

@@ -1,2 +1,3 @@
-import Search from "./model/Search";
-export default Search;
+import CrudFlow from "./flow/CrudFlow";
+import SearchFlow from "./flow/SearchFlow";
+export { SearchFlow, CrudFlow };

package/dist/index.js

@@ -3,5 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var Search_1 = __importDefault(require("./model/Search"));
-exports.default = Search_1.default;
+exports.CrudFlow = exports.SearchFlow = void 0;
+var CrudFlow_1 = __importDefault(require("./flow/CrudFlow"));
+exports.CrudFlow = CrudFlow_1.default;
+var SearchFlow_1 = __importDefault(require("./flow/SearchFlow"));
+exports.SearchFlow = SearchFlow_1.default;

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "c2-mongoose",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "Lib to make any search in database mongoose and use as basic crud",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsc",
-    "preversion": "tsc",
+    "watch": "tsc -w --skipLibCheck",
+    "build": "tsc --skipLibCheck",
+    "preversion": "tsc  --skipLibCheck",
     "postversion": "git push && git push --tags && npm publish",
     "publish-patch": "npm version patch",
     "publish-minor": "npm version minor",

package/src/flow/CrudFlow.ts

@@ -0,0 +1,41 @@
+import mongoose from "mongoose"
+import SearchFlow from "./SearchFlow"
+
+class CrudFlow<D> extends SearchFlow {
+
+    private repository: mongoose.Model<any>
+
+    constructor(repository: mongoose.Model<any>, model: any = {}) {
+        super(model as D)
+        this.repository = repository
+    }
+
+    public create = async (data: any, session: any = undefined) => {
+        return await this.repository.create([data], { session })
+    }
+
+    public delete = async (id: string, session: any = undefined) => {
+        await this.repository.findByIdAndRemove(id, { session })
+    }
+
+    public update = async (id: string, data: D, session: any = undefined): Promise<D> => {
+        const dataAfter = await this.repository.findByIdAndUpdate(id, { $set: data as any }, { returnDocument: 'after', session })
+        return dataAfter as D
+    }
+
+    public find = async (search: SearchFlow): Promise<SearchResponse<D>> => {
+        return await search.search(this.repository)
+    }
+
+    public getOne = async (model: D, sort = undefined): Promise<D> => {
+        const data = await super.findOne(this.repository, model, sort)
+        return data as D
+    }
+
+    public get = async (id: string, pop = "", sel = ""): Promise<D> => {
+        const data = await this.repository.findById(id).populate(pop).select(sel)
+        return data as D
+    }
+}
+
+export default CrudFlow

package/src/{model/Search.ts → flow/SearchFlow.ts}

@@ -2,7 +2,7 @@ import mongoose from "mongoose"
 import { dbCollation } from "../configuration/Environment"
 import { isEmpty, isNotEmpty } from "../utils/Utils"
 
-abstract class Search {
+abstract class SearchFlow {
   searchText: string
   order: string
   orderBy: string
@@ -133,6 +133,11 @@ abstract class Search {
     return await model.countDocuments(this.filters).exec()
   }
 
+  public async findOne(repository: mongoose.Model<any>, model: any, sort = undefined) {
+    return await repository.findOne(model)
+      .sort(sort)
+  }
+
   public sumBy = async (model: mongoose.Model<any>, _sum: any, _by: any): Promise<any[]> => {
     const ret = await model.aggregate(
       [
@@ -212,4 +217,4 @@ abstract class Search {
   }
 }
 
-export default Search
+export default SearchFlow

package/src/index.ts

@@ -1,3 +1,4 @@
-import Search from "./model/Search"
+import CrudFlow from "./flow/CrudFlow"
+import SearchFlow from "./flow/SearchFlow"
 
-export default Search
+export { SearchFlow, CrudFlow }