@modernlock/common 1.0.8 → 1.0.9

package/build/errors/auth-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class AuthenticationError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/auth-error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenticationError = void 0;
+const custom_error_1 = require("./custom-error");
+class AuthenticationError extends custom_error_1.CustomError {
+    constructor() {
+        super("Not Authenticated");
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, AuthenticationError.prototype);
+    }
+    ;
+    serializeErrors() {
+        return [{ message: "Not Authenticated" }];
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+;

package/build/errors/authorization-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class AuthorizationError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/authorization-error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorizationError = void 0;
+const custom_error_1 = require("./custom-error");
+class AuthorizationError extends custom_error_1.CustomError {
+    constructor() {
+        super("Not Authorized to perform this operation");
+        this.statusCode = 403;
+        Object.setPrototypeOf(this, AuthorizationError.prototype);
+    }
+    ;
+    serializeErrors() {
+        return [{ message: "Not Authorized to perform this operation" }];
+    }
+}
+exports.AuthorizationError = AuthorizationError;
+;

package/build/errors/custom-error.d.ts

@@ -0,0 +1,8 @@
+export declare abstract class CustomError extends Error {
+    abstract statusCode: number;
+    constructor(message: string);
+    abstract serializeErrors(): {
+        message: string;
+        field?: string;
+    }[];
+}

package/build/errors/custom-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomError = void 0;
+class CustomError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, CustomError.prototype);
+    }
+    ;
+}
+exports.CustomError = CustomError;
+;

package/build/errors/internal-server-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class InternalServerError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/internal-server-error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalServerError = void 0;
+const custom_error_1 = require("./custom-error");
+class InternalServerError extends custom_error_1.CustomError {
+    constructor() {
+        super("Internal server error");
+        this.statusCode = 500;
+        Object.setPrototypeOf(this, InternalServerError.prototype);
+    }
+    ;
+    serializeErrors() {
+        return [{ message: this.message }];
+    }
+}
+exports.InternalServerError = InternalServerError;
+;

package/build/errors/not-found-error.d.ts

@@ -0,0 +1,8 @@
+import { CustomError } from "./custom-error";
+export declare class NotFoundError extends CustomError {
+    statusCode: number;
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/not-found-error.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = void 0;
+const custom_error_1 = require("./custom-error");
+class NotFoundError extends custom_error_1.CustomError {
+    constructor() {
+        super("Route not found");
+        this.statusCode = 404;
+        Object.setPrototypeOf(this, NotFoundError.prototype);
+    }
+    ;
+    serializeErrors() {
+        return [{ message: "Not found error" }];
+    }
+}
+exports.NotFoundError = NotFoundError;

package/build/events/Group-notification-publisher.d.ts

@@ -0,0 +1,10 @@
+import { ExchangeTypes } from './exchange-types';
+import { Exchanges } from './exchanges';
+import { RoutingKeys } from "./routing-keys";
+import { GroupNotificationEvent } from "./events";
+import { Producer } from "./base-producer";
+export declare class GroupNotificationPublisher extends Producer<GroupNotificationEvent> {
+    exchange: Exchanges.mainExchange;
+    exchangeType: ExchangeTypes.direct;
+    routingKey: RoutingKeys.groupNotification;
+}

package/build/events/Group-notification-publisher.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupNotificationPublisher = void 0;
+const exchange_types_1 = require("./exchange-types");
+const exchanges_1 = require("./exchanges");
+const routing_keys_1 = require("./routing-keys");
+const base_producer_1 = require("./base-producer");
+class GroupNotificationPublisher extends base_producer_1.Producer {
+    constructor() {
+        super(...arguments);
+        this.exchange = exchanges_1.Exchanges.mainExchange;
+        this.exchangeType = exchange_types_1.ExchangeTypes.direct;
+        this.routingKey = routing_keys_1.RoutingKeys.groupNotification;
+    }
+}
+exports.GroupNotificationPublisher = GroupNotificationPublisher;
+;

package/build/events/base-consumer.d.ts

@@ -0,0 +1,16 @@
+import * as amqp from 'amqplib';
+import { RoutingKeys } from './routing-keys';
+import { ExchangeTypes } from './exchange-types';
+import { Exchanges } from './exchanges';
+import { Queues } from './queues';
+export declare abstract class Consumer {
+    abstract exchange: Exchanges;
+    abstract exchangeType: ExchangeTypes;
+    abstract routingKey: RoutingKeys;
+    abstract queue: Queues;
+    abstract onMessage(msg: amqp.Message, data: any, channel: amqp.Channel): void;
+    private channel;
+    constructor(channel: amqp.Channel);
+    listen(): Promise<void>;
+    parseMessage(msg: amqp.Message): any;
+}

package/build/events/base-consumer.js

@@ -0,0 +1,46 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Consumer = void 0;
+class Consumer {
+    constructor(channel) {
+        this.channel = channel;
+    }
+    ;
+    listen() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.channel.assertExchange(this.exchange, this.exchangeType);
+                const q = yield this.channel.assertQueue(this.queue);
+                yield this.channel.bindQueue(q.queue, this.exchange, this.routingKey);
+                this.channel.consume(q.queue, (msg) => {
+                    if (!msg)
+                        throw new Error('Message is required');
+                    const data = this.parseMessage(msg);
+                    this.onMessage(msg, data, this.channel);
+                });
+            }
+            catch (error) {
+                console.error('Failed to publish message:', error);
+            }
+        });
+    }
+    ;
+    parseMessage(msg) {
+        const data = msg.content;
+        return typeof data === 'string'
+            ? JSON.parse(data)
+            : JSON.parse(data.toString('utf8'));
+    }
+    ;
+}
+exports.Consumer = Consumer;
+;

package/build/events/base-producer.d.ts

@@ -0,0 +1,16 @@
+import * as amqp from 'amqplib';
+import { ExchangeTypes } from './exchange-types';
+import { Exchanges } from './exchanges';
+import { RoutingKeys } from "./routing-keys";
+interface Event {
+    data: any;
+}
+export declare abstract class Producer<T extends Event> {
+    abstract exchange: Exchanges;
+    abstract exchangeType: ExchangeTypes;
+    abstract routingKey: RoutingKeys;
+    private channel;
+    constructor(channel: amqp.Channel);
+    publish(data: T["data"]): Promise<void>;
+}
+export {};

package/build/events/base-producer.js

@@ -0,0 +1,33 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Producer = void 0;
+class Producer {
+    constructor(channel) {
+        this.channel = channel;
+    }
+    ;
+    publish(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.channel.assertExchange(this.exchange, this.exchangeType, { durable: true });
+                yield this.channel.publish(this.exchange, this.routingKey, Buffer.from(JSON.stringify(data)));
+                console.log('message published:', data);
+            }
+            catch (error) {
+                console.error('Failed to publish data:', error);
+                throw error;
+            }
+        });
+    }
+}
+exports.Producer = Producer;
+;

package/build/events/chat-notification-publisher.d.ts

@@ -0,0 +1,10 @@
+import { ExchangeTypes } from './exchange-types';
+import { Exchanges } from './exchanges';
+import { RoutingKeys } from "./routing-keys";
+import { ChatNotificationEvent } from "./events";
+import { Producer } from "./base-producer";
+export declare class ChatNotificationPublisher extends Producer<ChatNotificationEvent> {
+    exchange: Exchanges.mainExchange;
+    exchangeType: ExchangeTypes.direct;
+    routingKey: RoutingKeys.chatNotification;
+}

package/build/events/chat-notification-publisher.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatNotificationPublisher = void 0;
+const exchange_types_1 = require("./exchange-types");
+const exchanges_1 = require("./exchanges");
+const routing_keys_1 = require("./routing-keys");
+const base_producer_1 = require("./base-producer");
+class ChatNotificationPublisher extends base_producer_1.Producer {
+    constructor() {
+        super(...arguments);
+        this.exchange = exchanges_1.Exchanges.mainExchange;
+        this.exchangeType = exchange_types_1.ExchangeTypes.direct;
+        this.routingKey = routing_keys_1.RoutingKeys.chatNotification;
+    }
+}
+exports.ChatNotificationPublisher = ChatNotificationPublisher;
+;

package/build/events/events.d.ts

@@ -0,0 +1,20 @@
+import { Templates } from "./templates";
+export interface SingleNotificationEvent {
+    data: {
+        template: Templates;
+        args?: any;
+        userId: string;
+    };
+}
+export interface GroupNotificationEvent {
+    data: {
+        template: Templates;
+        args?: any;
+    };
+}
+export interface ChatNotificationEvent {
+    data: {
+        ids: string[];
+        message: any;
+    };
+}

package/build/events/events.js

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

package/build/events/exchange-types.d.ts

@@ -0,0 +1,6 @@
+export declare enum ExchangeTypes {
+    direct = "direct",
+    topic = "topic",
+    headers = "headers",
+    fanout = "fanout"
+}

package/build/events/exchange-types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExchangeTypes = void 0;
+var ExchangeTypes;
+(function (ExchangeTypes) {
+    ExchangeTypes["direct"] = "direct";
+    ExchangeTypes["topic"] = "topic";
+    ExchangeTypes["headers"] = "headers";
+    ExchangeTypes["fanout"] = "fanout";
+})(ExchangeTypes = exports.ExchangeTypes || (exports.ExchangeTypes = {}));
+;

package/build/events/exchanges.d.ts

@@ -0,0 +1,3 @@
+export declare enum Exchanges {
+    mainExchange = "mainExchange"
+}

package/build/events/exchanges.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Exchanges = void 0;
+var Exchanges;
+(function (Exchanges) {
+    Exchanges["mainExchange"] = "mainExchange";
+})(Exchanges = exports.Exchanges || (exports.Exchanges = {}));
+;

package/build/events/mappings.d.ts

@@ -0,0 +1,22 @@
+declare enum Categories {
+    platformUpdates = "platformUpdates",
+    profileCompletion = "profileCompletion",
+    accountManagement = "accountManagement",
+    tipsAndBestPractices = "tipsAndBestPractices",
+    mandatory = "mandatory"
+}
+export declare const templateCategoryMapping: {
+    accountVerificationActivation: Categories;
+    accountDeletingConfirmation: Categories;
+    passwordRecoveryInstructions: Categories;
+    notificationOfPlatformMaintenanceOrDowntime: Categories;
+    accountOnboardingInstructions: Categories;
+    reminderToCompleteProfile: Categories;
+    notificationOfNewLinkedWallet: Categories;
+    notificationOfNewLinkedEmail: Categories;
+    notificationOfModifiedLinkedWallet: Categories;
+    notificationOfModifiedEmail: Categories;
+    notificationOfModifiedPassword: Categories;
+    tipsAndBestPractices: Categories;
+};
+export {};

package/build/events/mappings.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templateCategoryMapping = void 0;
+var Categories;
+(function (Categories) {
+    Categories["platformUpdates"] = "platformUpdates";
+    Categories["profileCompletion"] = "profileCompletion";
+    Categories["accountManagement"] = "accountManagement";
+    Categories["tipsAndBestPractices"] = "tipsAndBestPractices";
+    Categories["mandatory"] = "mandatory";
+})(Categories || (Categories = {}));
+exports.templateCategoryMapping = {
+    accountVerificationActivation: Categories.mandatory,
+    accountDeletingConfirmation: Categories.mandatory,
+    passwordRecoveryInstructions: Categories.mandatory,
+    notificationOfPlatformMaintenanceOrDowntime: Categories.mandatory,
+    accountOnboardingInstructions: Categories.mandatory,
+    reminderToCompleteProfile: Categories.profileCompletion,
+    notificationOfNewLinkedWallet: Categories.accountManagement,
+    notificationOfNewLinkedEmail: Categories.accountManagement,
+    notificationOfModifiedLinkedWallet: Categories.accountManagement,
+    notificationOfModifiedEmail: Categories.accountManagement,
+    notificationOfModifiedPassword: Categories.mandatory,
+    tipsAndBestPractices: Categories.tipsAndBestPractices,
+};

package/build/events/queues.d.ts

@@ -0,0 +1,18 @@
+export declare enum Queues {
+    userCreatedQueue = "userCreatedQueue",
+    userUpdatedQueue = "userUpdatedQueue",
+    orderQueue = "orderQueue",
+    contractQueue = "contractQueue",
+    FileConfirmQeueu = "FileConfirmQeueu",
+    FileRemoveQeueu = "FileRemoveQeueu",
+    severalUserCreatedQeueu = "severalUserCreatedQeueu",
+    singleNotificationQeueu = "singleNotificationQeueu",
+    groupNotificationsQeueu = "groupNotificationsQeueu",
+    chatNotificationsQueue = "chatNotificationsQueue",
+    notificationAppQueue = "notificationAppQueue",
+    groupNotificationAppQueue = "groupNotificationAppQueue",
+    chatNotificationAppQueue = "chatNotificationAppQueue",
+    notificationEmailQueue = "notificationEmailQueue",
+    groupNotificationEmailQueue = "groupNotificationEmailQueue",
+    chatNotificationEmailQueue = "chatNotificationEmailQueue"
+}

package/build/events/queues.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queues = void 0;
+var Queues;
+(function (Queues) {
+    Queues["userCreatedQueue"] = "userCreatedQueue";
+    Queues["userUpdatedQueue"] = "userUpdatedQueue";
+    Queues["orderQueue"] = "orderQueue";
+    Queues["contractQueue"] = "contractQueue";
+    Queues["FileConfirmQeueu"] = "FileConfirmQeueu";
+    Queues["FileRemoveQeueu"] = "FileRemoveQeueu";
+    Queues["severalUserCreatedQeueu"] = "severalUserCreatedQeueu";
+    // notification service queues
+    Queues["singleNotificationQeueu"] = "singleNotificationQeueu";
+    Queues["groupNotificationsQeueu"] = "groupNotificationsQeueu";
+    Queues["chatNotificationsQueue"] = "chatNotificationsQueue";
+    // app workers queue
+    Queues["notificationAppQueue"] = "notificationAppQueue";
+    Queues["groupNotificationAppQueue"] = "groupNotificationAppQueue";
+    Queues["chatNotificationAppQueue"] = "chatNotificationAppQueue";
+    // email worker queue
+    Queues["notificationEmailQueue"] = "notificationEmailQueue";
+    Queues["groupNotificationEmailQueue"] = "groupNotificationEmailQueue";
+    Queues["chatNotificationEmailQueue"] = "chatNotificationEmailQueue";
+})(Queues = exports.Queues || (exports.Queues = {}));
+;

package/build/events/rabbitmq-wrapper.d.ts

@@ -0,0 +1,14 @@
+import * as amqp from 'amqplib';
+export declare class RabbitmqWrapper {
+    private connection;
+    private _channel;
+    private url;
+    private isConnecting;
+    private isConnected;
+    private reconnectRetries;
+    get channel(): amqp.Channel;
+    connect(url: string): Promise<void>;
+    connectWithRetries(url: string): Promise<void>;
+    private reconnect;
+}
+export declare const rabbitmqWrapper: RabbitmqWrapper;

package/build/events/rabbitmq-wrapper.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 __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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rabbitmqWrapper = exports.RabbitmqWrapper = void 0;
+const amqp = __importStar(require("amqplib"));
+const MAX_RETRIES = 5; // Maximum number of reconnection attempts
+const INITIAL_DELAY_MS = 1000; //
+class RabbitmqWrapper {
+    constructor() {
+        this.isConnecting = false;
+        this.isConnected = false;
+        this.reconnectRetries = 0; // Number of reconnection attempts
+    }
+    get channel() {
+        if (!this._channel) {
+            throw new Error("Cannot access RabbitMQ channel before connecting");
+        }
+        return this._channel;
+    }
+    connect(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnecting || this.isConnected)
+                return;
+            this.isConnecting = true;
+            try {
+                this.connection = yield amqp.connect(url);
+                this._channel = yield this.connection.createChannel();
+                console.log("Connected to RabbitMQ");
+                this.url = url;
+                this.isConnected = true;
+                // Handle close event (e.g., network issues or RabbitMQ server restart)
+                this.connection.on("close", () => {
+                    console.error("RabbitMQ connection closed unexpectedly");
+                    this.isConnected = false;
+                    this.isConnecting = false;
+                    // Implement reconnection logic here
+                    this.reconnect();
+                });
+                // Handle errors
+                this.connection.on("error", (err) => {
+                    console.error("RabbitMQ connection error:", err.message);
+                    this.isConnected = false;
+                    this.isConnecting = false;
+                    // Implement error handling logic here
+                    // You can choose to reconnect or take other actions based on the error
+                });
+            }
+            catch (error) {
+                console.error("Failed to connect to RabbitMQ:", error);
+                this.isConnecting = false;
+                // Implement error handling logic here
+                // You can choose to retry the connection or take other actions based on the error
+            }
+        });
+    }
+    connectWithRetries(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.connect(url);
+                console.log('Connected to RabbitMQ');
+            }
+            catch (error) {
+                console.error('Failed to connect to RabbitMQ:', error);
+                // Implement reconnection logic with exponential backoff
+                if (this.reconnectRetries < MAX_RETRIES) {
+                    const delay = INITIAL_DELAY_MS * Math.pow(2, this.reconnectRetries);
+                    console.log(`Retrying connection in ${delay} ms (attempt ${this.reconnectRetries + 1} of ${MAX_RETRIES})`);
+                    this.reconnectRetries++;
+                    setTimeout(() => {
+                        this.connectWithRetries(url);
+                    }, delay);
+                }
+                else {
+                    console.error(`Max reconnection attempts (${MAX_RETRIES}) reached. Could not reconnect to RabbitMQ.`);
+                }
+            }
+        });
+    }
+    reconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnecting && !this.isConnected) {
+                console.log("Attempting to reconnect to RabbitMQ...");
+                this.connectWithRetries(this.url);
+            }
+        });
+    }
+}
+exports.RabbitmqWrapper = RabbitmqWrapper;
+;
+exports.rabbitmqWrapper = new RabbitmqWrapper();

package/build/events/routing-keys.d.ts

@@ -0,0 +1,20 @@
+export declare enum RoutingKeys {
+    orderCreated = "order:created",
+    orderUpdated = "order:updated",
+    orderCanceled = "order:canceled",
+    userCreated = "user:created",
+    userUpdated = "user:updated",
+    userDeleted = "User:deleted",
+    severalUsersCreated = "severalUsers:created",
+    fileConfirmed = "file:confirmed",
+    fileRemoved = "file:removed",
+    groupNotification = "notification:groupNotification",
+    singleNotification = "notification:singleNotification",
+    chatNotification = "notification:chatNotification",
+    notificationEmailWorkers = "notification:email-workers",
+    groupNotificationEmailWorkers = "groupNotification:email-workers",
+    chatNotificationEmailWorkers = "chatNotification:email-workers",
+    notificationAppWorkers = "notification:app-workers",
+    groupNotificationAppWorkers = "groupNotification:app-workers",
+    chatNotificationAppWorkers = "chatNotification:app-workers"
+}

package/build/events/routing-keys.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutingKeys = void 0;
+var RoutingKeys;
+(function (RoutingKeys) {
+    RoutingKeys["orderCreated"] = "order:created";
+    RoutingKeys["orderUpdated"] = "order:updated";
+    RoutingKeys["orderCanceled"] = "order:canceled";
+    RoutingKeys["userCreated"] = "user:created";
+    RoutingKeys["userUpdated"] = "user:updated";
+    RoutingKeys["userDeleted"] = "User:deleted";
+    RoutingKeys["severalUsersCreated"] = "severalUsers:created";
+    RoutingKeys["fileConfirmed"] = "file:confirmed";
+    RoutingKeys["fileRemoved"] = "file:removed";
+    // notification service routing keys
+    RoutingKeys["groupNotification"] = "notification:groupNotification";
+    RoutingKeys["singleNotification"] = "notification:singleNotification";
+    RoutingKeys["chatNotification"] = "notification:chatNotification";
+    // Email workers routing keys
+    RoutingKeys["notificationEmailWorkers"] = "notification:email-workers";
+    RoutingKeys["groupNotificationEmailWorkers"] = "groupNotification:email-workers";
+    RoutingKeys["chatNotificationEmailWorkers"] = "chatNotification:email-workers";
+    // App workers routing keys
+    RoutingKeys["notificationAppWorkers"] = "notification:app-workers";
+    RoutingKeys["groupNotificationAppWorkers"] = "groupNotification:app-workers";
+    RoutingKeys["chatNotificationAppWorkers"] = "chatNotification:app-workers";
+})(RoutingKeys = exports.RoutingKeys || (exports.RoutingKeys = {}));
+;

package/build/events/single-notification-publisher.d.ts

@@ -0,0 +1,10 @@
+import { ExchangeTypes } from './exchange-types';
+import { Exchanges } from './exchanges';
+import { RoutingKeys } from "./routing-keys";
+import { SingleNotificationEvent } from "./events";
+import { Producer } from "./base-producer";
+export declare class SingleNotificationPublisher extends Producer<SingleNotificationEvent> {
+    exchange: Exchanges.mainExchange;
+    exchangeType: ExchangeTypes.direct;
+    routingKey: RoutingKeys.singleNotification;
+}

package/build/events/single-notification-publisher.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingleNotificationPublisher = void 0;
+const exchange_types_1 = require("./exchange-types");
+const exchanges_1 = require("./exchanges");
+const routing_keys_1 = require("./routing-keys");
+const base_producer_1 = require("./base-producer");
+class SingleNotificationPublisher extends base_producer_1.Producer {
+    constructor() {
+        super(...arguments);
+        this.exchange = exchanges_1.Exchanges.mainExchange;
+        this.exchangeType = exchange_types_1.ExchangeTypes.direct;
+        this.routingKey = routing_keys_1.RoutingKeys.singleNotification;
+    }
+}
+exports.SingleNotificationPublisher = SingleNotificationPublisher;
+;

package/build/events/templates.d.ts

@@ -0,0 +1,14 @@
+export declare enum Templates {
+    accountVerificationActivation = "accountVerificationActivation",
+    accountOnboardingInstructions = "accountOnboardingInstructions",
+    reminderToCompleteProfile = "reminderToCompleteProfile",
+    accountDeletingConfirmation = "accountDeletingConfirmation",
+    passwordRecoveryInstructions = "passwordRecoveryInstructions",
+    notificationOfNewLinkedWallet = "notificationOfNewLinkedWallet",
+    notificationOfNewLinkedEmail = "notificationOfNewLinkedEmail",
+    notificationOfModifiedLinkedWallet = "notificationOfModifiedLinkedWallet",
+    notificationOfModifiedEmail = "notificationOfModifiedEmail",
+    notificationOfModifiedPassword = "notificationOfModifiedPassword",
+    tipsAndBestPractices = "tipsAndBestPractices",
+    notificationOfPlatformMaintenanceOrDowntime = "notificationOfPlatformMaintenanceOrDowntime"
+}

package/build/events/templates.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Templates = void 0;
+var Templates;
+(function (Templates) {
+    Templates["accountVerificationActivation"] = "accountVerificationActivation";
+    Templates["accountOnboardingInstructions"] = "accountOnboardingInstructions";
+    Templates["reminderToCompleteProfile"] = "reminderToCompleteProfile";
+    Templates["accountDeletingConfirmation"] = "accountDeletingConfirmation";
+    Templates["passwordRecoveryInstructions"] = "passwordRecoveryInstructions";
+    Templates["notificationOfNewLinkedWallet"] = "notificationOfNewLinkedWallet";
+    Templates["notificationOfNewLinkedEmail"] = "notificationOfNewLinkedEmail";
+    Templates["notificationOfModifiedLinkedWallet"] = "notificationOfModifiedLinkedWallet";
+    Templates["notificationOfModifiedEmail"] = "notificationOfModifiedEmail";
+    Templates["notificationOfModifiedPassword"] = "notificationOfModifiedPassword";
+    Templates["tipsAndBestPractices"] = "tipsAndBestPractices";
+    Templates["notificationOfPlatformMaintenanceOrDowntime"] = "notificationOfPlatformMaintenanceOrDowntime";
+})(Templates = exports.Templates || (exports.Templates = {}));

package/build/index.d.ts

@@ -0,0 +1,23 @@
+export * from "./events/base-consumer";
+export * from "./events/base-producer";
+export * from "./events/exchanges";
+export * from "./events/exchange-types";
+export * from "./events/queues";
+export * from "./events/routing-keys";
+export * from "./events/rabbitmq-wrapper";
+export * from "./events/templates";
+export * from "./events/single-notification-publisher";
+export * from "./events/Group-notification-publisher";
+export * from "./events/chat-notification-publisher";
+export * from "./events/events";
+export * from "./events/mappings";
+export * from "./errors/custom-error";
+export * from "./errors/internal-server-error";
+export * from "./errors/not-found-error";
+export * from "./errors/auth-error";
+export * from "./middlewares/checkPermissions";
+export * from "./middlewares/checkAuth";
+export * from "./middlewares/error-handler";
+export * from "./middlewares/session";
+export * from "./utils/jwtEncryption";
+export * from "./utils/logger";

package/build/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./events/base-consumer"), exports);
+__exportStar(require("./events/base-producer"), exports);
+__exportStar(require("./events/exchanges"), exports);
+__exportStar(require("./events/exchange-types"), exports);
+__exportStar(require("./events/queues"), exports);
+__exportStar(require("./events/routing-keys"), exports);
+__exportStar(require("./events/rabbitmq-wrapper"), exports);
+__exportStar(require("./events/templates"), exports);
+__exportStar(require("./events/single-notification-publisher"), exports);
+__exportStar(require("./events/Group-notification-publisher"), exports);
+__exportStar(require("./events/chat-notification-publisher"), exports);
+__exportStar(require("./events/events"), exports);
+__exportStar(require("./events/mappings"), exports);
+__exportStar(require("./errors/custom-error"), exports);
+__exportStar(require("./errors/internal-server-error"), exports);
+__exportStar(require("./errors/not-found-error"), exports);
+__exportStar(require("./errors/auth-error"), exports);
+__exportStar(require("./middlewares/checkPermissions"), exports);
+__exportStar(require("./middlewares/checkAuth"), exports);
+__exportStar(require("./middlewares/error-handler"), exports);
+__exportStar(require("./middlewares/session"), exports);
+__exportStar(require("./utils/jwtEncryption"), exports);
+__exportStar(require("./utils/logger"), exports);

package/build/middlewares/checkAuth.d.ts

@@ -0,0 +1,2 @@
+import { NextFunction, Request, Response } from "express";
+export declare const authenticateToken: (req: Request, res: Response, next: NextFunction) => void;

package/build/middlewares/checkAuth.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authenticateToken = void 0;
+const auth_error_1 = require("../errors/auth-error");
+const jwtEncryption_1 = require("../utils/jwtEncryption");
+const authenticateToken = (req, res, next) => {
+    const { token } = req.session;
+    if (!token)
+        throw new auth_error_1.AuthenticationError();
+    const user = (0, jwtEncryption_1.jwtDecrypt)(token);
+    if (!user)
+        throw new auth_error_1.AuthenticationError();
+    else {
+        req.user = user;
+        next();
+    }
+    ;
+};
+exports.authenticateToken = authenticateToken;

package/build/middlewares/checkPermissions.d.ts

@@ -0,0 +1,3 @@
+import { NextFunction, Request, Response } from 'express';
+export declare function strongCheck(read: boolean, write: boolean): (req: Request, res: Response, next: NextFunction) => void;
+export declare function weakCheck(read: boolean, write: boolean): (req: Request, res: Response, next: NextFunction) => void;

package/build/middlewares/checkPermissions.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.weakCheck = exports.strongCheck = void 0;
+const auth_error_1 = require("../errors/auth-error");
+const authorization_error_1 = require("../errors/authorization-error");
+const internal_server_error_1 = require("../errors/internal-server-error");
+const jwtEncryption_1 = require("../utils/jwtEncryption");
+function strongCheck(read, write) {
+    return (req, res, next) => {
+        var _a, _b;
+        if (!(write && read))
+            throw new internal_server_error_1.InternalServerError();
+        const { token } = req.session;
+        if (!token)
+            throw new auth_error_1.AuthenticationError();
+        const user = (0, jwtEncryption_1.jwtDecrypt)(token);
+        if (!user)
+            throw new auth_error_1.AuthenticationError();
+        if (!user.isAdmin)
+            throw new authorization_error_1.AuthorizationError();
+        if (write && !((_a = user.permissions) === null || _a === void 0 ? void 0 : _a.write))
+            throw new authorization_error_1.AuthorizationError();
+        if (read && !((_b = user.permissions) === null || _b === void 0 ? void 0 : _b.read))
+            throw new authorization_error_1.AuthorizationError();
+        req.user = user;
+        next();
+    };
+}
+exports.strongCheck = strongCheck;
+;
+function weakCheck(read, write) {
+    return (req, res, next) => {
+        var _a, _b;
+        if (!(write && read))
+            throw new internal_server_error_1.InternalServerError();
+        const { token } = req.session;
+        if (!token)
+            throw new auth_error_1.AuthenticationError();
+        const user = (0, jwtEncryption_1.jwtDecrypt)(token);
+        if (!user)
+            throw new auth_error_1.AuthenticationError();
+        req.user = user;
+        if (!user.isAdmin) {
+            req.user.allowed = false;
+            return next();
+        }
+        if (write && !((_a = user.permissions) === null || _a === void 0 ? void 0 : _a.write)) {
+            req.user.allowed = false;
+            return next();
+        }
+        if (read && !((_b = user.permissions) === null || _b === void 0 ? void 0 : _b.read)) {
+            req.user.allowed = false;
+            return next();
+        }
+        req.user.allowed = true;
+        next();
+    };
+}
+exports.weakCheck = weakCheck;
+;

package/build/middlewares/error-handler.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response, NextFunction } from 'express';
+export declare const errorHandler: (err: Error, req: Request, res: Response, next: NextFunction) => Response<any, Record<string, any>> | undefined;

package/build/middlewares/error-handler.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorHandler = void 0;
+const custom_error_1 = require("../errors/custom-error");
+const errorHandler = (err, req, res, next) => {
+    if (err instanceof custom_error_1.CustomError) {
+        return res.status(err.statusCode).send({ errors: err.serializeErrors() });
+    }
+    res.status(400).send({
+        errors: [{ message: err.message ? err.message : "Something went wrong" }]
+    });
+};
+exports.errorHandler = errorHandler;

package/build/middlewares/session.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="qs" />
+/// <reference types="express" />
+export declare const session: () => import("express").RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+export default session;

package/build/middlewares/session.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 });
+exports.session = void 0;
+const cookie_session_1 = __importDefault(require("cookie-session"));
+const session = () => {
+    return (0, cookie_session_1.default)({
+        secret: process.env.SESSION_SECRET,
+        name: "session",
+        signed: false,
+        secure: false,
+        sameSite: "lax",
+        httpOnly: true,
+        path: "/",
+        maxAge: 60 * 60 * 24 * 100 * 365,
+    });
+};
+exports.session = session;
+exports.default = exports.session;

package/build/utils/jwtEncryption.d.ts

@@ -0,0 +1,2 @@
+export declare function jwtEncrypt(data: Record<string, any>, expiration?: string): string;
+export declare function jwtDecrypt(token: string): any;

package/build/utils/jwtEncryption.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jwtDecrypt = exports.jwtEncrypt = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+function jwtEncrypt(data, expiration = "5m") {
+    if (!process.env.ACCESS_TOKEN)
+        throw new Error("ACCESS_TOKEN must be defined");
+    let accessToken = jsonwebtoken_1.default.sign(data, process.env.ACCESS_TOKEN, {
+        expiresIn: expiration,
+    });
+    return accessToken;
+}
+exports.jwtEncrypt = jwtEncrypt;
+function jwtDecrypt(token) {
+    if (!process.env.ACCESS_TOKEN)
+        throw new Error("ACCESS_TOKEN must be defined");
+    let data = null;
+    jsonwebtoken_1.default.verify(token, process.env.ACCESS_TOKEN, (err, user) => {
+        if (err)
+            return;
+        else
+            data = user;
+    });
+    return data;
+}
+exports.jwtDecrypt = jwtDecrypt;

package/build/utils/logger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from 'winston';
+export declare const winstonLogger: (elasticsearchNode: string, name: string, level: string) => Logger;

package/build/utils/logger.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.winstonLogger = void 0;
+const winston_1 = __importDefault(require("winston"));
+const winston_elasticsearch_1 = require("winston-elasticsearch");
+const esTransformer = (logData) => {
+    return (0, winston_elasticsearch_1.ElasticsearchTransformer)(logData);
+};
+const winstonLogger = (elasticsearchNode, name, level) => {
+    const options = {
+        console: {
+            level,
+            handleExceptions: true,
+            json: false,
+            colorize: true
+        },
+        elasticsearch: {
+            level,
+            transformer: esTransformer,
+            clientOpts: {
+                node: elasticsearchNode,
+                log: level,
+                maxRetries: 2,
+                requestTimeout: 10000,
+                sniffOnStart: false
+            }
+        }
+    };
+    const esTransport = new winston_elasticsearch_1.ElasticsearchTransport(options.elasticsearch);
+    const logger = winston_1.default.createLogger({
+        exitOnError: false,
+        defaultMeta: { service: name },
+        transports: [new winston_1.default.transports.Console(options.console), esTransport]
+    });
+    return logger;
+};
+exports.winstonLogger = winstonLogger;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@modernlock/common",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "files": [
-    "build/**/*"
+    "./build/**/*"
   ],
   "scripts": {
     "clean": "del ./build/*",
@@ -25,7 +25,6 @@
     "@types/express": "4.17.17",
     "amqplib": "0.10.3",
     "cookie-session": "2.0.0",
-    "del": "^7.1.0",
     "express": "4.18.2",
     "jsonwebtoken": "9.0.0",
     "winston": "^3.12.0",