c2-mongoose 2.1.106 → 2.1.108

package/dist/flow/C2Flow.d.ts

@@ -0,0 +1,8 @@
+import mongoose from "mongoose";
+import { Options } from "../types/Options";
+declare class C2Flow<D> {
+    private repository;
+    constructor(repository: mongoose.Model<any>);
+    create(data: Partial<D>, options: Partial<Options>): Promise<any[]>;
+}
+export default C2Flow;

package/dist/flow/C2Flow.js

@@ -0,0 +1,70 @@
+"use strict";
+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 Logger_1 = require("../model/Logger");
+var BuildLogFlowItem_1 = __importDefault(require("./item/BuildLogFlowItem"));
+var C2Flow = /** @class */ (function () {
+    function C2Flow(repository) {
+        this.repository = repository;
+    }
+    C2Flow.prototype.create = function (data, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var dataAfter, log;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.repository.create([data], { session: options.session })];
+                    case 1:
+                        dataAfter = _a.sent();
+                        if (options.logger === false) {
+                            return [2 /*return*/, dataAfter];
+                        }
+                        log = BuildLogFlowItem_1.default.build(options, dataAfter, Logger_1.TypeOfOperation.CREATE);
+                        return [4 /*yield*/, Logger_1.LoggerRepository.create([log], { session: options.session })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, dataAfter];
+                }
+            });
+        });
+    };
+    return C2Flow;
+}());
+exports.default = C2Flow;

package/dist/flow/SearchFlow.js

@@ -225,11 +225,6 @@ var SearchFlow = /** @class */ (function () {
                         return [4 /*yield*/, model.aggregate([
                                 {
                                     $facet: facet
-                                    // {
-                                    //   items: stagesItems,
-                                    //   paging: stagesPaging,
-                                    //   metadata: stagesMetadata
-                                    // }
                                 },
                             ]).session(options === null || options === void 0 ? void 0 : options.session)];
                     case 1:

package/dist/flow/item/BuildLogFlowItem.d.ts

@@ -0,0 +1,7 @@
+import { ILogger, TypeOfOperation } from "../../model/Logger";
+import { Options } from "../../types/Options";
+declare class BuildLogFlowItem {
+    build(options: Partial<Options>, dataAfter: any[], operation: TypeOfOperation): Partial<ILogger>;
+}
+declare const _default: BuildLogFlowItem;
+export default _default;

package/dist/flow/item/BuildLogFlowItem.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var express_http_context_1 = __importDefault(require("express-http-context"));
+var BuildLogFlowItem = /** @class */ (function () {
+    function BuildLogFlowItem() {
+    }
+    BuildLogFlowItem.prototype.build = function (options, dataAfter, operation) {
+        var _a;
+        return {
+            user: (_a = options.owner) !== null && _a !== void 0 ? _a : express_http_context_1.default.get("user")._id,
+            owner: options.owner,
+            data: dataAfter,
+            operation: operation
+        };
+    };
+    return BuildLogFlowItem;
+}());
+exports.default = new BuildLogFlowItem;

package/dist/model/Logger.d.ts

@@ -0,0 +1,208 @@
+import moment from 'moment';
+import mongoose, { Types } from 'mongoose';
+import SearchFlow from '../flow/SearchFlow';
+declare enum TypeOfOperation {
+    "CREATE" = "CREATE",
+    "UPDATE" = "UPDATE",
+    "DELETE" = "DELETE"
+}
+interface ILogger {
+    owner: Types.ObjectId;
+    user: Types.ObjectId;
+    createdAtDateTime: moment.Moment;
+    operation: TypeOfOperation;
+    data: any;
+}
+declare const LoggerModel: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.ResolveSchemaOptions<{
+    timestamps: {
+        createdAt: string;
+    };
+}>, {
+    owner: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    user: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    operation: string;
+    data?: any;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    owner: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    user: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    operation: string;
+    data?: any;
+}>> & Omit<mongoose.FlatRecord<{
+    owner: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    user: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    operation: string;
+    data?: any;
+}> & {
+    _id: Types.ObjectId;
+}, never>>;
+declare class LoggerSearch extends SearchFlow {
+    model: Partial<ILogger>;
+    constructor(params: any);
+    buildFilters(): void;
+}
+declare const LoggerRepository: mongoose.Model<{
+    owner: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    user: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    operation: string;
+    data?: any;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    owner: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    user: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    operation: string;
+    data?: any;
+}> & Omit<{
+    owner: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    user: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    operation: string;
+    data?: any;
+} & {
+    _id: Types.ObjectId;
+}, never>, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.ResolveSchemaOptions<{
+    timestamps: {
+        createdAt: string;
+    };
+}>, {
+    owner: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    user: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    operation: string;
+    data?: any;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    owner: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    user: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    operation: string;
+    data?: any;
+}>> & Omit<mongoose.FlatRecord<{
+    owner: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    user: {
+        prototype?: Types.ObjectId | undefined;
+        cacheHexString?: unknown;
+        generate?: {} | undefined;
+        createFromTime?: {} | undefined;
+        createFromHexString?: {} | undefined;
+        isValid?: {} | undefined;
+    };
+    operation: string;
+    data?: any;
+}> & {
+    _id: Types.ObjectId;
+}, never>>>;
+export { ILogger, TypeOfOperation, LoggerModel, LoggerRepository, LoggerSearch };

package/dist/model/Logger.js

@@ -0,0 +1,94 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerSearch = exports.LoggerRepository = exports.LoggerModel = exports.TypeOfOperation = void 0;
+var mongoose_1 = __importStar(require("mongoose"));
+var SearchFlow_1 = __importDefault(require("../flow/SearchFlow"));
+var Utils_1 = require("../utils/Utils");
+var TypeOfOperation;
+(function (TypeOfOperation) {
+    TypeOfOperation["CREATE"] = "CREATE";
+    TypeOfOperation["UPDATE"] = "UPDATE";
+    TypeOfOperation["DELETE"] = "DELETE";
+})(TypeOfOperation || (TypeOfOperation = {}));
+exports.TypeOfOperation = TypeOfOperation;
+var LoggerModel = new mongoose_1.Schema({
+    owner: { type: mongoose_1.Types.ObjectId, required: true, immutable: true },
+    user: { type: mongoose_1.Types.ObjectId, required: true, immutable: true },
+    operation: { type: String, enum: TypeOfOperation, required: true, immutable: true },
+    data: { type: mongoose_1.default.Schema.Types.Mixed, immutable: true }
+}, {
+    timestamps: { createdAt: 'createdAtDateTime' }
+});
+exports.LoggerModel = LoggerModel;
+var LoggerSearch = /** @class */ (function (_super) {
+    __extends(LoggerSearch, _super);
+    function LoggerSearch(params) {
+        var _this = _super.call(this, params) || this;
+        _this.model = params;
+        _this.buildFilters();
+        return _this;
+    }
+    LoggerSearch.prototype.buildFilters = function () {
+        var filters = this.buildDefaultFilters(this);
+        if ((0, Utils_1.isEmpty)(filters.$and)) {
+            filters = { $and: [] };
+        }
+        if ((0, Utils_1.isNotEmpty)(this.searchText)) {
+            var regex = this.buildRegex(this.searchText);
+            var condition = {
+                $or: [
+                // { 'name': { $regex: regex } },
+                ]
+            };
+            filters.$and.push(condition);
+        }
+        if (filters.$and.length === 0)
+            delete filters['$and'];
+        this.filters = filters;
+    };
+    return LoggerSearch;
+}(SearchFlow_1.default));
+exports.LoggerSearch = LoggerSearch;
+var LoggerRepository = (0, mongoose_1.model)('c2-mongoose-logger', LoggerModel);
+exports.LoggerRepository = LoggerRepository;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c2-mongoose",
-  "version": "2.1.106",
+  "version": "2.1.108",
   "description": "Lib to make any search in database mongoose and use as basic crud",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,6 +29,7 @@
   "homepage": "https://gitlab.com/cabral_consultoria/c2-mongoose#readme",
   "dependencies": {
     "dotenv": "^16.0.3",
+    "express-http-context": "^1.2.4",
     "moment": "^2.29.4",
     "mongoose": "^7.0.1"
   },

package/src/flow/C2Flow.ts

@@ -0,0 +1,40 @@
+
+import mongoose from "mongoose"
+import { ILogger, LoggerRepository, TypeOfOperation } from "../model/Logger"
+import { Options } from "../types/Options"
+import BuildLogFlowItem from "./item/BuildLogFlowItem"
+
+class C2Flow<D> {
+
+    private repository: mongoose.Model<any>
+
+    constructor(repository: mongoose.Model<any>) {
+        this.repository = repository
+    }
+
+    public async create(data: Partial<D>, options: Partial<Options>) {
+        let dataAfter = await this.repository.create([data], { session: options.session })
+
+        if (options.logger === false) {
+            return dataAfter
+        }
+
+        let log: Partial<ILogger> = BuildLogFlowItem.build(options, dataAfter, TypeOfOperation.CREATE)
+        await LoggerRepository.create([log], { session: options.session })
+
+        return dataAfter
+    }
+
+
+    // public async updateById(id: Types.ObjectId, data: any, session: any = undefined): Promise<D> {
+    //     const dataAfter = await this.repository.findByIdAndUpdate(id, data, { returnDocument: 'after', session })
+    //     return dataAfter as D
+    // }
+
+    // public async updateByModel(searcher: SearchFlow, data: any, params: any): Promise<D> {
+    //     const dataAfter = await this.repository.findOneAndUpdate(searcher.filters, data, params)
+    //     return dataAfter as D
+    // }
+}
+
+export default C2Flow

package/src/flow/SearchFlow.ts

@@ -171,11 +171,6 @@ abstract class SearchFlow {
       [
         {
           $facet: facet
-          // {
-          //   items: stagesItems,
-          //   paging: stagesPaging,
-          //   metadata: stagesMetadata
-          // }
         },
       ]
     ).session(options?.session as ClientSession)

package/src/flow/item/BuildLogFlowItem.ts

@@ -0,0 +1,16 @@
+import httpContext from "express-http-context"
+import { ILogger, TypeOfOperation } from "../../model/Logger"
+import { Options } from "../../types/Options"
+
+class BuildLogFlowItem {
+  build(options: Partial<Options>, dataAfter: any[], operation: TypeOfOperation): Partial<ILogger> {
+    return {
+      user: options.owner ?? httpContext.get("user")._id,
+      owner: options.owner,
+      data: dataAfter,
+      operation
+    }
+  }
+}
+
+export default new BuildLogFlowItem

package/src/model/Logger.ts

@@ -0,0 +1,63 @@
+import moment from 'moment'
+import mongoose, { Schema, Types, model } from 'mongoose'
+import SearchFlow from '../flow/SearchFlow'
+import { isEmpty, isNotEmpty } from '../utils/Utils'
+
+enum TypeOfOperation {
+  "CREATE" = "CREATE",
+  "UPDATE" = "UPDATE",
+  "DELETE" = "DELETE",
+}
+
+interface ILogger {
+  owner: Types.ObjectId
+  user: Types.ObjectId
+  createdAtDateTime: moment.Moment
+  operation: TypeOfOperation
+  data: any
+}
+
+const LoggerModel = new Schema({
+  owner: { type: Types.ObjectId, required: true, immutable: true },
+  user: { type: Types.ObjectId, required: true, immutable: true },
+  operation: { type: String, enum: TypeOfOperation, required: true, immutable: true },
+  data: { type: mongoose.Schema.Types.Mixed, immutable: true }
+}, {
+  timestamps: { createdAt: 'createdAtDateTime' }
+})
+
+class LoggerSearch extends SearchFlow {
+  model: Partial<ILogger>
+  constructor(params: any) {
+    super(params)
+    this.model = params
+    this.buildFilters()
+  }
+
+  buildFilters() {
+    let filters = this.buildDefaultFilters(this)
+
+    if (isEmpty(filters.$and)) {
+      filters = { $and: [] } as any
+    }
+
+    if (isNotEmpty(this.searchText)) {
+      let regex = this.buildRegex(this.searchText)
+      let condition = {
+        $or: [
+          // { 'name': { $regex: regex } },
+        ]
+      }
+      filters.$and.push(condition)
+    }
+
+    if (filters.$and.length === 0)
+      delete filters['$and']
+    this.filters = filters
+  }
+}
+
+const LoggerRepository = model('c2-mongoose-logger', LoggerModel)
+
+
+export { ILogger, TypeOfOperation, LoggerModel, LoggerRepository, LoggerSearch }

package/src/types/Options.d.ts

@@ -0,0 +1,8 @@
+import { ClientSession, Types } from "mongoose";
+
+declare interface Options {
+  session: ClientSession
+  logger: boolean
+  owner: Types.ObjectId
+  user: Types.ObjectId
+}