@ecom-micro/common 2.0.2 → 2.0.4

package/README.md

@@ -0,0 +1,19 @@
+### ecom-micro/common helps developer to catch production level nodejs application error easy way.
+
+`app.use(errorHandler)` function is to catch global level error. It's alternative to express error controller. You need to use it in your `app.js` or where you write your express app logic.
+
+#### Example to use any error class
+
+```JavaScript
+import { BadRequestError } from '@ecom-micro/common';
+
+return next(new BadRequestError('Invalid email or password'));
+// OR
+throw new BadRequestError('Invalid email or password');
+```
+
+##### List of method
+
+```JavaScript
+import { BadRequestError, NotFoundError, errorHandler } from '@ecom-micro/common';
+```

package/build/events/baseListener.d.ts

@@ -0,0 +1,15 @@
+import { Message, Connection, Channel } from 'amqplib';
+import { Subjects } from '../types/subjects';
+interface Event {
+    subject: Subjects;
+    data: any;
+}
+export declare abstract class Listener<T extends Event> {
+    abstract subject: T['subject'];
+    abstract onMessage(data: T['data'], msg: Message, channel: Channel): void;
+    private client;
+    constructor(client: Connection);
+    listen(): Promise<void>;
+    parseMessage(msg: Message): any;
+}
+export {};

package/build/events/baseListener.js

@@ -0,0 +1,68 @@
+"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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Listener = void 0;
+var Listener = /** @class */ (function () {
+    function Listener(client) {
+        this.client = client;
+    }
+    Listener.prototype.listen = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                this.client.createChannel().then(function (channel) {
+                    channel.assertQueue(_this.subject);
+                    channel.consume(_this.subject, function (message) {
+                        if (message !== null) {
+                            console.log("Message Received to: ".concat(_this.subject));
+                            var parseMsg = _this.parseMessage(message);
+                            _this.onMessage(parseMsg, message, channel);
+                        }
+                    });
+                });
+                return [2 /*return*/];
+            });
+        });
+    };
+    Listener.prototype.parseMessage = function (msg) {
+        var data = msg.content;
+        return typeof data === 'string' ? JSON.parse(data) : JSON.parse(data.toString('utf8'));
+    };
+    return Listener;
+}());
+exports.Listener = Listener;

package/build/events/basePublisher.d.ts

@@ -0,0 +1,13 @@
+import { Connection } from 'amqplib';
+import { Subjects } from '../types/subjects';
+interface Event {
+    subject: Subjects;
+    data: any;
+}
+export declare abstract class Publisher<T extends Event> {
+    abstract subject: T['subject'];
+    protected client: Connection;
+    constructor(client: Connection);
+    publish(data: T['data']): Promise<void>;
+}
+export {};

package/build/events/basePublisher.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Publisher = void 0;
+var Publisher = /** @class */ (function () {
+    function Publisher(client) {
+        this.client = client;
+    }
+    Publisher.prototype.publish = function (data) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.client
+                .createChannel()
+                .then(function (channel) {
+                channel.assertQueue(_this.subject, { durable: true });
+                channel.sendToQueue(_this.subject, Buffer.from(JSON.stringify(data)));
+                console.log("Event published to subject: ".concat(_this.subject));
+                resolve();
+            })
+                .catch(function (error) { return reject(error); });
+        });
+    };
+    return Publisher;
+}());
+exports.Publisher = Publisher;

package/build/events/productCreatedEvent.d.ts

@@ -0,0 +1,11 @@
+import { Subjects } from '../types/subjects';
+export interface ProductCreatedEvent {
+    subject: Subjects.ProductCreated;
+    data: {
+        id: string;
+        title: string;
+        price: number;
+        productUrl: string;
+        sellerId: string;
+    };
+}

package/build/events/productCreatedEvent.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/events/productCreatedListener.d.ts

@@ -0,0 +1,8 @@
+import { Message, Channel } from 'amqplib';
+import { Subjects } from '../types/subjects';
+import { Listener } from './baseListener';
+import { ProductCreatedEvent } from './productCreatedEvent';
+export declare class ProductCreatedListener extends Listener<ProductCreatedEvent> {
+    subject: Subjects.ProductCreated;
+    onMessage(data: ProductCreatedEvent['data'], message: Message, channel: Channel): void;
+}

package/build/events/productCreatedListener.js

@@ -0,0 +1,33 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductCreatedListener = void 0;
+var subjects_1 = require("../types/subjects");
+var baseListener_1 = require("./baseListener");
+var ProductCreatedListener = /** @class */ (function (_super) {
+    __extends(ProductCreatedListener, _super);
+    function ProductCreatedListener() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.subject = subjects_1.Subjects.ProductCreated;
+        return _this;
+    }
+    ProductCreatedListener.prototype.onMessage = function (data, message, channel) {
+        channel.ack(message);
+    };
+    return ProductCreatedListener;
+}(baseListener_1.Listener));
+exports.ProductCreatedListener = ProductCreatedListener;

package/build/events/productCreatedPublisher.d.ts

@@ -0,0 +1,6 @@
+import { Subjects } from '../types/subjects';
+import { Publisher } from './basePublisher';
+import { ProductCreatedEvent } from './productCreatedEvent';
+export declare class ProductCreatedPublisher extends Publisher<ProductCreatedEvent> {
+    subject: Subjects.ProductCreated;
+}

package/build/events/productCreatedPublisher.js

@@ -0,0 +1,30 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductCreatedPublisher = void 0;
+var subjects_1 = require("../types/subjects");
+var basePublisher_1 = require("./basePublisher");
+var ProductCreatedPublisher = /** @class */ (function (_super) {
+    __extends(ProductCreatedPublisher, _super);
+    function ProductCreatedPublisher() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.subject = subjects_1.Subjects.ProductCreated;
+        return _this;
+    }
+    return ProductCreatedPublisher;
+}(basePublisher_1.Publisher));
+exports.ProductCreatedPublisher = ProductCreatedPublisher;

package/build/index.d.ts

@@ -6,3 +6,9 @@ export * from './errors/requestValidationError';
 export * from './middleware/errorHandler';
 export * from './middleware/protect';
 export * from './middleware/requestValidation';
+export * from './events/baseListener';
+export * from './events/basePublisher';
+export * from './events/productCreatedEvent';
+export * from './events/productCreatedListener';
+export * from './events/productCreatedPublisher';
+export * from './types/subjects';

package/build/index.js

@@ -22,3 +22,9 @@ __exportStar(require("./errors/requestValidationError"), exports);
 __exportStar(require("./middleware/errorHandler"), exports);
 __exportStar(require("./middleware/protect"), exports);
 __exportStar(require("./middleware/requestValidation"), exports);
+__exportStar(require("./events/baseListener"), exports);
+__exportStar(require("./events/basePublisher"), exports);
+__exportStar(require("./events/productCreatedEvent"), exports);
+__exportStar(require("./events/productCreatedListener"), exports);
+__exportStar(require("./events/productCreatedPublisher"), exports);
+__exportStar(require("./types/subjects"), exports);

package/build/types/subjects.d.ts

@@ -0,0 +1,10 @@
+export declare enum Subjects {
+    ProductCreated = "product-created",
+    ProductUpdated = "product-updated",
+    ProductDeleted = "product-deleted",
+    OrderCreated = "order-created",
+    OrderUpdated = "order-updated",
+    OrderCanceled = "order-cancelled",
+    ProductAddedCart = "product-add-to-cart",
+    ProductRemoveCart = "product-remove-to-cart"
+}

package/build/types/subjects.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subjects = void 0;
+var Subjects;
+(function (Subjects) {
+    Subjects["ProductCreated"] = "product-created";
+    Subjects["ProductUpdated"] = "product-updated";
+    Subjects["ProductDeleted"] = "product-deleted";
+    Subjects["OrderCreated"] = "order-created";
+    Subjects["OrderUpdated"] = "order-updated";
+    Subjects["OrderCanceled"] = "order-cancelled";
+    Subjects["ProductAddedCart"] = "product-add-to-cart";
+    Subjects["ProductRemoveCart"] = "product-remove-to-cart";
+})(Subjects = exports.Subjects || (exports.Subjects = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecom-micro/common",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -16,14 +16,16 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "express": "^4.18.2",
+    "@types/amqplib": "^0.10.0",
+    "@types/cookie-session": "^2.0.44",
     "@types/express": "^4.17.14",
-    "express-validator": "^6.14.2",
     "@types/express-validator": "^3.0.0",
     "@types/jsonwebtoken": "^8.5.9",
-    "jsonwebtoken": "^8.5.1",
-    "@types/cookie-session": "^2.0.44",
+    "amqplib": "^0.10.3",
     "cookie-session": "^2.0.0",
+    "express": "^4.18.2",
+    "express-validator": "^6.14.2",
+    "jsonwebtoken": "^8.5.1",
     "typescript": "^4.8.4"
   }
 }