@aptana/multichannel-common 2.9.12

package/core/infrastructure/events/Listener.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Listener = exports.Connection = void 0;
+const core_1 = require("../../../core");
+const Connection_1 = require("./Connection");
+Object.defineProperty(exports, "Connection", { enumerable: true, get: function () { return Connection_1.Connection; } });
+class Listener {
+    static instance;
+    connection;
+    channel;
+    service;
+    extraQueues = {};
+    exclusiveConnection = false;
+    constructor() {
+        this.connection = Connection_1.Connection.getConnection(this.connectionName);
+    }
+    init() {
+        this.channel = this.connection.createChannel({
+            json: true,
+            setup: (channel) => this.setup(channel)
+        });
+        return this;
+    }
+    setup(channel) {
+        channel.assertExchange(this.exchange, 'topic', { durable: false });
+        channel.assertQueue(this.queue);
+        channel.bindQueue(this.queue, this.exchange, this.topic);
+        channel.prefetch(parseInt(process.env.MQ_PREFETCH ?? '10'));
+    }
+    setupExtraQueue(channel, suffixes = ['backup']) {
+        suffixes.push('json_parse_error');
+        suffixes.forEach((suffix) => {
+            this.extraQueues[suffix] = `${this.queue}.${suffix}`;
+            const extraTopic = `${this.topic}.${suffix}`;
+            channel.assertQueue(this.extraQueues[suffix], { durable: false });
+            channel.bindQueue(this.extraQueues[suffix], this.exchange, extraTopic);
+        });
+    }
+    listen() {
+        return this.channel.consume(this.queue, (msg) => {
+            const parsedMessage = this.parseMessage(msg);
+            core_1.logger.debug('Receive message %s', this.constructor.name, { parsedMessage });
+            if (!parsedMessage)
+                return;
+            this.onMessage(parsedMessage, () => this.channel.ack(msg), () => this.channel.nack(msg));
+        });
+    }
+    get queue() {
+        let queue = [];
+        queue.push(this.service);
+        queue.push(this.constructor.name);
+        queue.push(this.exchange);
+        queue.push(this.topic);
+        return queue.join('.');
+    }
+    get connectionName() {
+        return this.exclusiveConnection ? this.constructor.name : 'listener';
+    }
+    parseMessage(msg) {
+        try {
+            const json = msg.content.toString();
+            return JSON.parse(json);
+        }
+        catch (error) {
+            core_1.logger.error("Error while parsing message", {
+                message: error.message,
+                stack: error.stack,
+            });
+            if (this.extraQueues.json_parse_error) {
+                this.channel.sendToQueue(this.extraQueues.json_parse_error, msg.content);
+            }
+            this.channel.ack(msg);
+            return;
+        }
+    }
+}
+exports.Listener = Listener;

package/core/infrastructure/events/Worker.d.ts

@@ -0,0 +1,9 @@
+import { Worker as WorkerContract } from '../../../core/domain/events/Worker';
+import { Listener as ListenerContract } from '../../../core/domain/events/Listener';
+export declare class Worker implements WorkerContract {
+    protected listeners: ListenerContract[];
+    constructor(listeners: any[]);
+    protected registerListeners(listeners: any[]): void;
+    protected resolve(klass: any): ListenerContract;
+    start(): void;
+}

package/core/infrastructure/events/Worker.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Worker = void 0;
+const Container_1 = require("../../../core/infrastructure/Container");
+const Listener_1 = require("./Listener");
+const logger_1 = __importDefault(require("../../../core/utils/logger"));
+class Worker {
+    listeners = [];
+    constructor(listeners) {
+        this.registerListeners(listeners);
+    }
+    registerListeners(listeners) {
+        listeners.forEach((listener) => {
+            const instance = this.resolve(listener);
+            this.listeners.push(instance);
+        });
+    }
+    resolve(klass) {
+        if (klass instanceof Listener_1.Listener) {
+            return klass;
+        }
+        return Container_1.Container.get(klass);
+    }
+    start() {
+        logger_1.default.info('Register listeners %s', this.listeners);
+        for (const listener of this.listeners) {
+            listener.init().listen();
+        }
+    }
+}
+exports.Worker = Worker;

package/core/infrastructure/events/grpc/Connection.d.ts

@@ -0,0 +1,9 @@
+import { Server } from "@grpc/grpc-js";
+import { Root } from "protobufjs";
+export declare class Connection {
+    private static connection;
+    private static server;
+    constructor();
+    static getConnection(): Root;
+    static getServer(): Server;
+}

package/core/infrastructure/events/grpc/Connection.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Connection = void 0;
+const grpc_js_1 = require("@grpc/grpc-js");
+const protobufjs_1 = require("protobufjs");
+class Connection {
+    static connection = null;
+    static server = null;
+    constructor() {
+        Connection.connection = new protobufjs_1.Root();
+        const Event = new protobufjs_1.Type("Event").add(new protobufjs_1.Field("data", 1, "string"));
+        const Listener = new protobufjs_1.Type("Listener").add(new protobufjs_1.Field("message", 1, "string"));
+        Connection.connection.add(Event).add(Listener);
+        if (!Connection.server) {
+            Connection.server = new grpc_js_1.Server();
+            Connection.server.bindAsync(process.env.APP_GRPC, grpc_js_1.ServerCredentials.createInsecure(), () => {
+                Connection.server.start();
+            });
+        }
+    }
+    static getConnection() {
+        if (!Connection.connection) {
+            new Connection();
+        }
+        return Connection.connection;
+    }
+    static getServer() {
+        if (!Connection.server) {
+            new Connection();
+        }
+        return Connection.server;
+    }
+}
+exports.Connection = Connection;

package/core/infrastructure/events/grpc/Event.d.ts

@@ -0,0 +1,12 @@
+import { Root } from "protobufjs";
+export declare abstract class Event<T> {
+    protected connection: Root;
+    protected channel: any;
+    protected payload: T;
+    abstract exchange: string;
+    constructor(payload: T);
+    init(): this;
+    protected setup(): void;
+    publish<Response>(options?: {}): Promise<Response>;
+    protected parseMessage(message: any): any;
+}

package/core/infrastructure/events/grpc/Event.js

@@ -0,0 +1,80 @@
+"use strict";
+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.Event = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const protoLoader = __importStar(require("@grpc/proto-loader"));
+const protobufjs_1 = require("protobufjs");
+const Connection_1 = require("./Connection");
+const logger_1 = __importDefault(require("../../../../core/utils/logger"));
+class Event {
+    connection;
+    channel;
+    payload;
+    constructor(payload) {
+        this.connection = Connection_1.Connection.getConnection();
+        this.payload = payload;
+        this.setup();
+    }
+    init() {
+        const packageDefinition = protoLoader.fromJSON(this.connection.toJSON());
+        const channel = grpc.loadPackageDefinition(packageDefinition);
+        this.channel = new channel[this.constructor.name](this.exchange, grpc.credentials.createInsecure());
+        return this;
+    }
+    setup() {
+        try {
+            if (!this.connection.get(this.constructor.name)) {
+                const service = new protobufjs_1.Service(this.constructor.name).add(new protobufjs_1.Method("Publish", "rpc", 'Event', 'Listener'));
+                this.connection.add(service);
+            }
+        }
+        catch (error) {
+            logger_1.default.error('Error while connecting the server', { error: error.stack });
+        }
+    }
+    publish(options = {}) {
+        logger_1.default.debug('Publish message %s', this.constructor.name);
+        return new Promise((resolve, reject) => {
+            const handleMessage = (err, response) => {
+                if (err) {
+                    console.log({ err });
+                    reject(err);
+                }
+                const message = this.parseMessage(response?.message);
+                resolve(message);
+            };
+            this.channel.publish({ data: JSON.stringify(this.payload) }, handleMessage);
+        });
+    }
+    parseMessage(message) {
+        const json = message.toString();
+        return JSON.parse(json);
+    }
+}
+exports.Event = Event;

package/core/infrastructure/events/grpc/Listener.d.ts

@@ -0,0 +1,16 @@
+import { Root } from 'protobufjs';
+import { Server } from '@grpc/grpc-js';
+export declare abstract class Listener<T> {
+    protected connection: Root;
+    protected server: Server;
+    protected channel: any;
+    protected payload: T;
+    abstract exchange: string;
+    constructor();
+    init(): this;
+    protected setup(): Promise<void>;
+    abstract onMessage(data: T): Promise<any>;
+    listen(): Promise<void>;
+    get constructorName(): string;
+    protected parseMessage(message: any): any;
+}

package/core/infrastructure/events/grpc/Listener.js

@@ -0,0 +1,74 @@
+"use strict";
+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.Listener = void 0;
+const protoLoader = __importStar(require("@grpc/proto-loader"));
+const protobufjs_1 = require("protobufjs");
+const Connection_1 = require("./Connection");
+const grpc_js_1 = require("@grpc/grpc-js");
+const logger_1 = __importDefault(require("../../../../core/utils/logger"));
+class Listener {
+    connection;
+    server;
+    channel;
+    payload;
+    constructor() {
+        this.connection = Connection_1.Connection.getConnection();
+        this.server = Connection_1.Connection.getServer();
+        this.setup();
+    }
+    init() {
+        const packageDefinition = protoLoader.fromJSON(this.connection.toJSON());
+        this.channel = (0, grpc_js_1.loadPackageDefinition)(packageDefinition);
+        return this;
+    }
+    async setup() {
+        if (!this.connection.get(this.constructorName)) {
+            const service = new protobufjs_1.Service(this.constructorName).add(new protobufjs_1.Method("Publish", "rpc", 'Event', 'Listener'));
+            this.connection.add(service);
+        }
+    }
+    async listen() {
+        this.server.addService(this.channel[this.constructorName].service, {
+            publish: async (call, callback) => {
+                const parsedMessage = this.parseMessage(call.request.data);
+                logger_1.default.info('Receive message %s', this.constructor.name, { parsedMessage });
+                const res = await this.onMessage(parsedMessage);
+                callback(null, { message: JSON.stringify(res) });
+            }
+        });
+    }
+    get constructorName() {
+        return this.constructor.name.replace(/Listener/g, '');
+    }
+    parseMessage(message) {
+        const json = message.toString();
+        return JSON.parse(json);
+    }
+}
+exports.Listener = Listener;

package/core/infrastructure/events/rpc/Event.d.ts

@@ -0,0 +1,13 @@
+import { Event as BaseEvent, Channel } from "../../../../core";
+export declare abstract class Event<T> extends BaseEvent<T> {
+    readonly correlationId: string;
+    constructor(payload: T);
+    setup(channel: Channel): void;
+    publish<Response>(options?: {}): Promise<Response>;
+    publishWithoutPersistence<Response>(options?: {}): Promise<Response>;
+    get queue(): string;
+    get exclusiveQueue(): string;
+    protected uniqueId(): string;
+    protected parseMessage(msg: any): any;
+    protected close(): Promise<any>;
+}

package/core/infrastructure/events/rpc/Event.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Event = void 0;
+const core_1 = require("../../../../core");
+const promises_1 = require("timers/promises");
+class Event extends core_1.Event {
+    correlationId;
+    constructor(payload) {
+        super(payload);
+        this.correlationId = this.uniqueId();
+    }
+    setup(channel) {
+        channel.assertQueue(this.exclusiveQueue, { exclusive: true });
+    }
+    publish(options = {}) {
+        core_1.logger.debug("Publish message %s", this.constructor.name);
+        return new Promise((resolve) => {
+            const correlationId = this.correlationId;
+            const handleMessage = async (msg) => {
+                if (msg.properties.correlationId == correlationId) {
+                    const parsedMessage = this.parseMessage(msg);
+                    this.channel.removeListener("message", handleMessage);
+                    await this.close();
+                    resolve(parsedMessage);
+                }
+            };
+            this.channel.consume(this.exclusiveQueue, handleMessage, { noAck: true });
+            this.channel.sendToQueue(this.queue, this.payload, Object.assign({
+                correlationId: correlationId,
+                replyTo: this.exclusiveQueue,
+                deliveryMode: 2,
+                persistent: true,
+            }, options));
+        });
+    }
+    publishWithoutPersistence(options = {}) {
+        core_1.logger.debug("Publish message %s", this.constructor.name);
+        return new Promise((resolve) => {
+            const correlationId = this.correlationId;
+            const handleMessage = async (msg) => {
+                if (msg.properties.correlationId == correlationId) {
+                    const parsedMessage = this.parseMessage(msg);
+                    this.channel.removeListener("message", handleMessage);
+                    await this.close();
+                    resolve(parsedMessage);
+                }
+            };
+            this.channel.consume(this.exclusiveQueue, handleMessage, { noAck: true });
+            this.channel.sendToQueue(this.queue, this.payload, Object.assign({
+                correlationId: correlationId,
+                replyTo: this.exclusiveQueue,
+                deliveryMode: 1,
+                persistent: false,
+            }, options));
+        });
+    }
+    get queue() {
+        const queue = [];
+        queue.push("Rmq");
+        queue.push("rpc");
+        queue.push(this.exchange);
+        queue.push(this.topic);
+        return queue.join(".");
+    }
+    get exclusiveQueue() {
+        const executiveQueue = [];
+        executiveQueue.push(this.constructor.name);
+        executiveQueue.push(this.exchange);
+        executiveQueue.push(this.topic);
+        executiveQueue.push(this.correlationId);
+        return executiveQueue.join(".");
+    }
+    uniqueId() {
+        return String(new core_1.UniqueId());
+    }
+    parseMessage(msg) {
+        const json = msg.content.toString();
+        return JSON.parse(json);
+    }
+    async close() {
+        return await (0, promises_1.setTimeout)(1000, async () => {
+            if (this.channel) {
+                this.channel
+                    .deleteQueue(this.exclusiveQueue)
+                    .then(() => {
+                    core_1.logger.info("The response queue is cleared");
+                })
+                    .catch((err) => {
+                    core_1.logger.error("Failed to delete queue: ", { msg: err.message });
+                });
+                await this.channel.close().catch((reason) => {
+                    core_1.logger.error("Failed to close rpc channel", { reason });
+                });
+            }
+        });
+    }
+}
+exports.Event = Event;

package/core/infrastructure/events/rpc/Listener.d.ts

@@ -0,0 +1,6 @@
+import { Listener as BaseListener, Channel } from '../../../../core';
+export declare abstract class Listener<T> extends BaseListener<T> {
+    setup(channel: Channel): void;
+    listen(): Promise<import("amqplib").Replies.Consume>;
+    get queue(): string;
+}

package/core/infrastructure/events/rpc/Listener.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Listener = void 0;
+const core_1 = require("../../../../core");
+class Listener extends core_1.Listener {
+    setup(channel) {
+        channel.assertQueue(this.queue, { durable: true });
+        channel.prefetch(parseInt(process.env.MQ_PREFETCH ?? '10'));
+    }
+    listen() {
+        return this.channel.consume(this.queue, async (msg) => {
+            const parsedMessage = this.parseMessage(msg);
+            core_1.logger.debug('Receive message %s', this.constructor.name, { parsedMessage });
+            const res = await this.onMessage(parsedMessage, () => this.channel.ack);
+            await this.channel.sendToQueue(msg.properties.replyTo, res, {
+                correlationId: msg.properties.correlationId
+            });
+            this.channel.ack(msg);
+        });
+    }
+    get queue() {
+        const queue = [];
+        queue.push('Rmq');
+        queue.push('rpc');
+        queue.push(this.exchange);
+        queue.push(this.topic);
+        return queue.join('.');
+    }
+}
+exports.Listener = Listener;

package/core/infrastructure/http/App.d.ts

@@ -0,0 +1,15 @@
+import express from 'express';
+import 'express-async-errors';
+import { Controller } from '../../../core/infrastructure/Controller';
+export declare class App {
+    protected app: express.Application;
+    protected controllers: any[];
+    constructor(controllers: any[], options?: any);
+    start(): void;
+    protected registerMiddleware(): void;
+    protected registerControllers(controllers: any[]): void;
+    protected resolve(klass: any): Controller;
+    protected registerHealthHandlers(health: any): void;
+    protected registerDetailControllers(): void;
+    protected registerErrorHandlers(): void;
+}

package/core/infrastructure/http/App.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.App = void 0;
+const express_1 = __importDefault(require("express"));
+const helmet_1 = __importDefault(require("helmet"));
+const cors_1 = __importDefault(require("cors"));
+require("express-async-errors");
+const Container_1 = require("../../../core/infrastructure/Container");
+const Controller_1 = require("../../../core/infrastructure/Controller");
+const loggerMiddleware_1 = require("../../../core/infrastructure/http/middleware/loggerMiddleware");
+const routeNotFoundMiddleware_1 = require("../../../core/infrastructure/http/middleware/routeNotFoundMiddleware");
+const errorMiddleware_1 = require("../../../core/infrastructure/http/middleware/errorMiddleware");
+const alwaysAcceptJsonMiddleware_1 = require("../../../core/infrastructure/http/middleware/alwaysAcceptJsonMiddleware");
+const HealthController_1 = __importDefault(require("../../../core/modules/health/useCases/health/HealthController"));
+const DetailController_1 = __importDefault(require("../../../core/modules/service/useCases/detail/DetailController"));
+class App {
+    app = (0, express_1.default)();
+    controllers = [];
+    constructor(controllers, options = {}) {
+        this.registerMiddleware();
+        this.registerHealthHandlers(options.health);
+        this.registerDetailControllers();
+        this.registerControllers([...this.controllers, ...controllers]);
+        this.registerErrorHandlers();
+    }
+    start() {
+        this.app.listen(3000, () => {
+            console.info('App listening @', 3000);
+        });
+    }
+    registerMiddleware() {
+        this.app.disable('x-powered-by');
+        this.app.use(loggerMiddleware_1.loggerMiddleware);
+        this.app.use(alwaysAcceptJsonMiddleware_1.alwaysAcceptJsonMiddleware);
+        this.app.use((0, cors_1.default)({ origin: '*' }));
+        // this.app.use(compression());
+        this.app.use((0, helmet_1.default)());
+        this.app.use(express_1.default.json({ limit: '2048mb' }));
+        this.app.use(express_1.default.urlencoded({ limit: '2048mb', extended: true }));
+    }
+    registerControllers(controllers) {
+        controllers.forEach((controller) => {
+            const instance = this.resolve(controller);
+            this.app.use('/', instance.router);
+        });
+    }
+    resolve(klass) {
+        if (klass instanceof Controller_1.Controller) {
+            return klass;
+        }
+        return Container_1.Container.get(klass);
+    }
+    registerHealthHandlers(health) {
+        Container_1.Container.set('health', health);
+        if (!Container_1.Container.has('HealthController')) {
+            this.controllers.push(HealthController_1.default);
+            return;
+        }
+        const healthController = Container_1.Container.get('HealthController');
+        this.controllers.push(healthController);
+    }
+    registerDetailControllers() {
+        this.controllers.push(DetailController_1.default);
+    }
+    registerErrorHandlers() {
+        this.app.use(routeNotFoundMiddleware_1.routeNotFoundMiddleware);
+        this.app.use(errorMiddleware_1.errorMiddleware);
+    }
+}
+exports.App = App;

package/core/infrastructure/http/middleware/alwaysAcceptJsonMiddleware.d.ts

@@ -0,0 +1,2 @@
+import { NextFunction, Request, Response } from 'express';
+export declare function alwaysAcceptJsonMiddleware(req: Request, res: Response, next: NextFunction): void;

package/core/infrastructure/http/middleware/alwaysAcceptJsonMiddleware.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alwaysAcceptJsonMiddleware = void 0;
+function alwaysAcceptJsonMiddleware(req, res, next) {
+    req.headers['accept'] = 'application/json';
+    next();
+}
+exports.alwaysAcceptJsonMiddleware = alwaysAcceptJsonMiddleware;

package/core/infrastructure/http/middleware/errorMiddleware.d.ts

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

package/core/infrastructure/http/middleware/errorMiddleware.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorMiddleware = void 0;
+const logger_1 = __importDefault(require("../../../../core/utils/logger"));
+const AppError_1 = require("../../../../core/errors/AppError");
+const response_1 = require("../../../../core/utils/response");
+function errorMiddleware(err, req, res, next) {
+    if (err instanceof AppError_1.AppError) {
+        logger_1.default.error(err.message, { cause: err.cause, stack: err.stack, res: err.serializeErrors() });
+        return (0, response_1.sendErrorResponse)(res, err.serializeErrors(), err.status);
+    }
+    logger_1.default.error(err.message, { cause: err.cause, stack: err.stack });
+    return (0, response_1.sendErrorResponse)(res, [{ message: err.message }]);
+}
+exports.errorMiddleware = errorMiddleware;

package/core/infrastructure/http/middleware/loggerMiddleware.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare const loggerMiddleware: (req: import("http").IncomingMessage, res: import("http").ServerResponse<import("http").IncomingMessage>, callback: (err?: Error | undefined) => void) => void;

package/core/infrastructure/http/middleware/loggerMiddleware.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loggerMiddleware = void 0;
+const morgan_1 = __importDefault(require("morgan"));
+const morgan_json_1 = __importDefault(require("morgan-json"));
+const logger_1 = require("../../../../core/utils/logger");
+exports.loggerMiddleware = (0, morgan_1.default)((0, morgan_json_1.default)(':method :url :status :res[content-length] :response-time :user-agent'), {
+    stream: new class {
+        write(message) {
+            const logMessage = JSON.parse(message);
+            logger_1.logger.info(logMessage);
+        }
+    }
+});

package/core/infrastructure/http/middleware/routeNotFoundMiddleware.d.ts

@@ -0,0 +1,2 @@
+import { NextFunction, Request, Response } from 'express';
+export declare function routeNotFoundMiddleware(req: Request, res: Response, next: NextFunction): void;