@wabot-dev/framework 0.5.6 → 0.5.8

package/dist/src/addon/chat-bot/anthropic/AnthropicChatAdapter.js

@@ -6,6 +6,7 @@ import '../../../feature/chat-bot/ChatBot.js';
 import 'uuid';
 import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 import { safeJsonParse } from '../../../feature/chat-bot/safeJsonParse.js';
+import { extractChatMessageText } from '../../../feature/chat-bot/extractChatMessageText.js';
 import { Anthropic } from '@anthropic-ai/sdk';
 
 let AnthropicChatAdapter = class AnthropicChatAdapter {
@@ -58,7 +59,7 @@ let AnthropicChatAdapter = class AnthropicChatAdapter {
         if (!item.text) {
             throw new Error('Assistant message content is empty');
         }
-        return { role: 'assistant', content: item.text };
+        return { role: 'assistant', content: extractChatMessageText(item) };
     }
     mapFunctionCall(item) {
         return [

package/dist/src/addon/chat-bot/deepseek/DeepSeekChatAdapter.js

@@ -1,4 +1,10 @@
 import { Logger } from '../../../core/logger/Logger.js';
+import '../../../feature/chat-bot/ChatBot.js';
+import '../../../core/injection/index.js';
+import 'uuid';
+import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import '../../../core/error/setupErrorHandlers.js';
+import { extractChatMessageText } from '../../../feature/chat-bot/extractChatMessageText.js';
 import { OpenAI } from 'openai';
 
 class DeepSeekChatAdapter {
@@ -52,7 +58,7 @@ class DeepSeekChatAdapter {
         if (!item.text) {
             throw new Error('User message content is empty');
         }
-        return { role: 'user', content: item.text };
+        return { role: 'user', content: extractChatMessageText(item) };
     }
     mapBotMessage(item) {
         if (!item.text) {

package/dist/src/addon/chat-bot/google/GoogleChatAdapter.js

@@ -7,6 +7,7 @@ import '../../../feature/chat-bot/ChatBot.js';
 import 'uuid';
 import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
 import { safeJsonParse } from '../../../feature/chat-bot/safeJsonParse.js';
+import { extractChatMessageText } from '../../../feature/chat-bot/extractChatMessageText.js';
 import { GoogleGenAI } from '@google/genai';
 
 let GoogleChatAdapter = class GoogleChatAdapter {
@@ -54,7 +55,7 @@ let GoogleChatAdapter = class GoogleChatAdapter {
         if (!item.text) {
             throw new Error('Bot message content is empty');
         }
-        return { role: 'model', parts: [{ text: item.text }] };
+        return { role: 'model', parts: [{ text: extractChatMessageText(item) }] };
     }
     mapFunctionCall(item) {
         return [

package/dist/src/addon/chat-bot/openia/OpenaiChatAdapter.js

@@ -1,7 +1,12 @@
 import { __decorate } from 'tslib';
+import '../../../feature/chat-bot/ChatBot.js';
+import { singleton } from '../../../core/injection/index.js';
+import 'uuid';
+import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import '../../../core/error/setupErrorHandlers.js';
+import { extractChatMessageText } from '../../../feature/chat-bot/extractChatMessageText.js';
 import { Logger } from '../../../core/logger/Logger.js';
 import { OpenAI } from 'openai';
-import { singleton } from '../../../core/injection/index.js';
 
 let OpenaiChatAdapter = class OpenaiChatAdapter {
     openai = new OpenAI();
@@ -38,7 +43,7 @@ let OpenaiChatAdapter = class OpenaiChatAdapter {
     mapConectionMessage(item) {
         const content = [];
         if (item.text)
-            content.push({ type: 'input_text', text: item.text });
+            content.push({ type: 'input_text', text: extractChatMessageText(item) });
         if (item.images) {
             for (const image of item.images) {
                 content.push({

package/dist/src/addon/chat-controller/wasender/@whatsAppByWasender.js

@@ -0,0 +1,20 @@
+import { container } from '../../../core/injection/index.js';
+import { WhatsAppByWasenderChannelConfig } from './WhatsAppByWasenderChannelConfig.js';
+import { ControllerMetadataStore } from '../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import '../../../feature/chat-controller/ChatResolver.js';
+import '../../../feature/chat-controller/runChatControllers.js';
+import { WhatsAppByWasenderChannel } from './WhatsAppByWasenderChannel.js';
+
+function whatsAppByWasender(config) {
+    return function (target, propertyKey) {
+        const store = container.resolve(ControllerMetadataStore);
+        store.saveChannelMetadata({
+            channelConstructor: WhatsAppByWasenderChannel,
+            functionName: propertyKey.toString(),
+            controllerConstructor: target.constructor,
+            channelConfig: new WhatsAppByWasenderChannelConfig(config ?? {}),
+        });
+    };
+}
+
+export { whatsAppByWasender };

package/dist/src/addon/chat-controller/wasender/WasenderWebhookController.js

@@ -0,0 +1,90 @@
+import { __decorate, __metadata } from 'tslib';
+import { Logger } from '../../../core/logger/Logger.js';
+import '../../../core/injection/index.js';
+import '../../../feature/rest-controller/metadata/RestControllerMetadataStore.js';
+import { onPost } from '../../../feature/rest-controller/metadata/@onPost.js';
+import { extractNumberFromWasenderMessageKey } from './extractNumberFromWasenderKey.js';
+import { IncomingMessage } from 'http';
+
+class WasenderWebhookController {
+    wasender;
+    listener;
+    logger = new Logger('wabot:wasender-webhook');
+    constructor(wasender, listener) {
+        this.wasender = wasender;
+        this.listener = listener;
+    }
+    async handleWebhook(req) {
+        const rawBody = await this.getRawBody(req);
+        const event = await this.parseEvent(req, rawBody);
+        this.logger.trace(`received event ${event.event}`);
+        switch (event.event) {
+            case 'messages.received':
+                const messages = Array.isArray(event.data.messages)
+                    ? event.data.messages
+                    : [event.data.messages];
+                await this.handleMessages(messages);
+                break;
+            default:
+                this.logger.warn(`unhandled event type ${event.event}`);
+        }
+    }
+    async handleMessages(messages) {
+        if (!this.listener) {
+            this.logger.warn('No listener registered, ignoring messages');
+            return;
+        }
+        for (const message of messages) {
+            const from = extractNumberFromWasenderMessageKey(message.key);
+            this.logger.trace(`new message from '${from}'`);
+            if (message.message.conversation) {
+                const chatConnection = {
+                    chatType: 'PRIVATE',
+                    channelName: 'WhatsAppByWasenderChannel',
+                    id: from,
+                };
+                await this.listener({
+                    chatConnection,
+                    message: {
+                        text: message.message.conversation,
+                        senderName: message.pushName,
+                        senderId: from,
+                    },
+                });
+            }
+        }
+    }
+    async parseEvent(req, rawBody) {
+        const adapter = {
+            getHeader: (name) => {
+                const value = req.headers[name.toLowerCase()];
+                return Array.isArray(value) ? value[0] : value;
+            },
+            getRawBody: () => rawBody,
+        };
+        const event = await this.wasender.handleWebhookEvent(adapter);
+        return event;
+    }
+    getRawBody(req) {
+        return new Promise((resolve, reject) => {
+            let data = '';
+            req.on('data', (chunk) => {
+                data += chunk;
+            });
+            req.on('end', () => {
+                resolve(data);
+            });
+            req.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+}
+__decorate([
+    onPost({ disableJsonParser: true, disableUrlEncodedParser: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [IncomingMessage]),
+    __metadata("design:returntype", Promise)
+], WasenderWebhookController.prototype, "handleWebhook", null);
+
+export { WasenderWebhookController };

package/dist/src/addon/chat-controller/wasender/WhatsAppByWasenderChannel.js

@@ -0,0 +1,58 @@
+import { __decorate, __metadata } from 'tslib';
+import { injectable } from '../../../core/injection/index.js';
+import { Env } from '../../../core/env/Env.js';
+import { Logger } from '../../../core/logger/Logger.js';
+import { WhatsAppByWasenderChannelConfig } from './WhatsAppByWasenderChannelConfig.js';
+import { WhatsAppReceiverByWasender } from './WhatsAppReceiverByWasender.js';
+import { WhatsAppSenderByWasender } from './WhatsAppSenderByWasender.js';
+
+let WhatsAppByWasenderChannel = class WhatsAppByWasenderChannel {
+    logger = new Logger('wabot:whatsapp-by-wasender-channel');
+    sender;
+    receiver;
+    phoneNumber;
+    constructor(config, env) {
+        const apiKey = config.apiKey ?? env.requireString('WASENDER_API_KEY');
+        const webhookSecret = config.webhookSecret ?? env.requireString('WASENDER_WEBHOOK_SECRET');
+        this.phoneNumber = config.phoneNumber ?? env.requireString('WASENDER_PHONE_NUMBER');
+        this.sender = new WhatsAppSenderByWasender(apiKey, config.retryOptions);
+        this.receiver = new WhatsAppReceiverByWasender({
+            apiKey,
+            webhookSecret,
+            webhookPath: config.webhookPath,
+            retryOptions: config.retryOptions,
+        });
+    }
+    listen(callback) {
+        this.receiver.listenMessage(async (message) => {
+            try {
+                await callback({
+                    chatConnection: message.chatConnection,
+                    message: message.message,
+                    reply: async (replyMessage) => {
+                        await this.sender.send({
+                            from: this.phoneNumber,
+                            to: message.chatConnection.id,
+                            message: replyMessage,
+                        });
+                    },
+                });
+            }
+            catch (err) {
+                this.logger.error('Failed to handle WhatsApp message', err);
+            }
+        });
+    }
+    connect() {
+        this.receiver.connect();
+    }
+    disconnect() {
+        this.receiver.disconnect();
+    }
+};
+WhatsAppByWasenderChannel = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [WhatsAppByWasenderChannelConfig, Env])
+], WhatsAppByWasenderChannel);
+
+export { WhatsAppByWasenderChannel };

package/dist/src/addon/chat-controller/wasender/WhatsAppByWasenderChannelConfig.js

@@ -0,0 +1,16 @@
+class WhatsAppByWasenderChannelConfig {
+    apiKey;
+    webhookSecret;
+    phoneNumber;
+    webhookPath;
+    retryOptions;
+    constructor(config) {
+        this.apiKey = config.apiKey;
+        this.webhookSecret = config.webhookSecret;
+        this.phoneNumber = config.phoneNumber;
+        this.webhookPath = config.webhookPath ?? '/wasender/hook';
+        this.retryOptions = config.retryOptions ?? { enabled: true, maxRetries: 3 };
+    }
+}
+
+export { WhatsAppByWasenderChannelConfig };

package/dist/src/addon/chat-controller/wasender/WhatsAppReceiverByWasender.js

@@ -0,0 +1,39 @@
+import { __decorate, __metadata } from 'tslib';
+import '../../../core/injection/index.js';
+import '../../../feature/rest-controller/metadata/RestControllerMetadataStore.js';
+import { restController } from '../../../feature/rest-controller/metadata/@restController.js';
+import { runRestControllers } from '../../../feature/rest-controller/runRestControllers.js';
+import { createWasender } from '../../../node_modules/wasenderapi/dist/index.js';
+import { WasenderWebhookController } from './WasenderWebhookController.js';
+
+class WhatsAppReceiverByWasender {
+    config;
+    wasender;
+    listener = null;
+    constructor(config) {
+        this.config = config;
+        this.wasender = createWasender(config.apiKey, undefined, undefined, undefined, config.retryOptions, config.webhookSecret);
+    }
+    listenMessage(listener) {
+        this.listener = listener;
+    }
+    connect() {
+        const wasender = this.wasender;
+        const listener = this.listener;
+        let UniqueController = class UniqueController extends WasenderWebhookController {
+            constructor() {
+                super(wasender, listener);
+            }
+        };
+        UniqueController = __decorate([
+            restController(this.config.webhookPath),
+            __metadata("design:paramtypes", [])
+        ], UniqueController);
+        runRestControllers([UniqueController]);
+    }
+    disconnect() {
+        // Nothing to disconnect
+    }
+}
+
+export { WhatsAppReceiverByWasender };

package/dist/src/addon/chat-controller/wasender/WhatsAppSenderByWasender.js

@@ -0,0 +1,33 @@
+import { Logger } from '../../../core/logger/Logger.js';
+import { createWasender } from '../../../node_modules/wasenderapi/dist/index.js';
+
+class WhatsAppSenderByWasender {
+    wasender;
+    logger = new Logger('wabot:whatsapp-sender-by-wasender');
+    constructor(apiKey, retryOptions) {
+        this.wasender = createWasender(apiKey, undefined, undefined, undefined, retryOptions, undefined);
+    }
+    async send(request) {
+        try {
+            const textPayload = {
+                messageType: 'text',
+                to: `+${request.to.replace(/\D+/g, '')}`,
+                text: request.message.text ?? 'No Text',
+            };
+            const result = await this.wasender.send(textPayload);
+            this.logger.trace(`message sent from '${request.from}' to '${request.to}'`);
+            this.logger.trace(`rate limit remaining: ${result.rateLimit?.remaining}`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to send message from '${request.from}' to '${request.to}'`, error);
+            if (error instanceof Error) {
+                throw new Error(error.message, { cause: error });
+            }
+            else {
+                throw new Error('error sending message');
+            }
+        }
+    }
+}
+
+export { WhatsAppSenderByWasender };

package/dist/src/addon/chat-controller/wasender/extractNumberFromWasenderKey.js

@@ -0,0 +1,5 @@
+function extractNumberFromWasenderMessageKey(key) {
+    return key.cleanedSenderPn ?? key.senderPn?.split('@')?.at(0) ?? key.remoteJid.split('@').at(0);
+}
+
+export { extractNumberFromWasenderMessageKey };

package/dist/src/addon/chat-controller/whatsapp-by-wasender/@whatsAppByWasender.js

@@ -0,0 +1,20 @@
+import { container } from '../../../core/injection/index.js';
+import { WhatsAppByWasenderChannelConfig } from './WhatsAppByWasenderChannelConfig.js';
+import { ControllerMetadataStore } from '../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import '../../../feature/chat-controller/ChatResolver.js';
+import '../../../feature/chat-controller/runChatControllers.js';
+import { WhatsAppByWasenderChannel } from './WhatsAppByWasenderChannel.js';
+
+function whatsAppByWasender(config) {
+    return function (target, propertyKey) {
+        const store = container.resolve(ControllerMetadataStore);
+        store.saveChannelMetadata({
+            channelConstructor: WhatsAppByWasenderChannel,
+            functionName: propertyKey.toString(),
+            controllerConstructor: target.constructor,
+            channelConfig: new WhatsAppByWasenderChannelConfig(config),
+        });
+    };
+}
+
+export { whatsAppByWasender };

package/dist/src/addon/chat-controller/whatsapp-by-wasender/WhatsAppByWasenderChannel.js

@@ -0,0 +1,52 @@
+import { __decorate, __metadata } from 'tslib';
+import { injectable } from '../../../core/injection/index.js';
+import { Logger } from '../../../core/logger/Logger.js';
+import { WhatsAppByWasenderChannelConfig } from './WhatsAppByWasenderChannelConfig.js';
+import { WhatsAppReceiverByWasender } from './WhatsAppReceiverByWasender.js';
+import { WhatsAppSenderByWasender } from './WhatsAppSenderByWasender.js';
+
+let WhatsAppByWasenderChannel = class WhatsAppByWasenderChannel {
+    config;
+    sender;
+    receiver;
+    logger = new Logger('wabot:whatsapp-by-wasender-channel');
+    constructor(config, sender, receiver) {
+        this.config = config;
+        this.sender = sender;
+        this.receiver = receiver;
+    }
+    listen(callback) {
+        this.receiver.listenMessage(async (message) => {
+            try {
+                await callback({
+                    chatConnection: message.chatConnection,
+                    message: message.message,
+                    reply: async (replyMessage) => {
+                        await this.sender.send({
+                            from: this.config.phoneNumber,
+                            to: message.chatConnection.id,
+                            message: replyMessage,
+                        });
+                    },
+                });
+            }
+            catch (err) {
+                this.logger.error('Failed to handle WhatsApp message', err);
+            }
+        });
+    }
+    connect() {
+        this.receiver.connect();
+    }
+    disconnect() {
+        this.receiver.disconnect();
+    }
+};
+WhatsAppByWasenderChannel = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [WhatsAppByWasenderChannelConfig,
+        WhatsAppSenderByWasender,
+        WhatsAppReceiverByWasender])
+], WhatsAppByWasenderChannel);
+
+export { WhatsAppByWasenderChannel };

package/dist/src/addon/chat-controller/whatsapp-by-wasender/WhatsAppByWasenderChannelConfig.js

@@ -0,0 +1,16 @@
+class WhatsAppByWasenderChannelConfig {
+    apiKey;
+    webhookSecret;
+    phoneNumber;
+    webhookPath;
+    retryOptions;
+    constructor(config) {
+        this.apiKey = config.apiKey;
+        this.webhookSecret = config.webhookSecret;
+        this.phoneNumber = config.phoneNumber;
+        this.webhookPath = config.webhookPath ?? '/wasender/hook';
+        this.retryOptions = config.retryOptions ?? { enabled: true, maxRetries: 3 };
+    }
+}
+
+export { WhatsAppByWasenderChannelConfig };

package/dist/src/addon/chat-controller/whatsapp-by-wasender/WhatsAppReceiverByWasender.js

@@ -0,0 +1,106 @@
+import { __decorate, __metadata } from 'tslib';
+import { Logger } from '../../../core/logger/Logger.js';
+import { injectable } from '../../../core/injection/index.js';
+import { ExpressProvider } from '../../../feature/express/ExpressProvider.js';
+import { createWasender } from '../../../node_modules/wasenderapi/dist/index.js';
+import { WhatsAppByWasenderChannelConfig } from './WhatsAppByWasenderChannelConfig.js';
+import { extractNumberFromWasenderMessageKey } from './extractNumberFromWasenderKey.js';
+
+let WhatsAppReceiverByWasender = class WhatsAppReceiverByWasender {
+    expressProvider;
+    config;
+    wasender;
+    listener = null;
+    logger = new Logger('wabot:whatsapp-receiver-by-wasender');
+    constructor(expressProvider, config) {
+        this.expressProvider = expressProvider;
+        this.config = config;
+        this.wasender = createWasender(config.apiKey, undefined, undefined, undefined, config.retryOptions, config.webhookSecret);
+    }
+    listenMessage(listener) {
+        this.listener = listener;
+    }
+    connect() {
+        const expressApp = this.expressProvider.getExpress();
+        expressApp.post(this.config.webhookPath, async (req, res) => {
+            try {
+                const rawBody = await this.getRawBody(req);
+                const event = await this.parseEvent(req, rawBody);
+                this.logger.trace(`received event ${event.event}`);
+                switch (event.event) {
+                    case 'messages.received':
+                        const messages = Array.isArray(event.data.messages)
+                            ? event.data.messages
+                            : [event.data.messages];
+                        await this.handleMessages(messages);
+                        break;
+                    default:
+                        this.logger.warn(`unhandled event type ${event.event}`);
+                }
+                res.sendStatus(200);
+            }
+            catch (err) {
+                this.logger.error('Failed to handle Wasender webhook', err);
+                res.sendStatus(500);
+            }
+        });
+        this.expressProvider.listen();
+    }
+    disconnect() {
+        // Nothing to disconnect
+    }
+    async handleMessages(messages) {
+        if (!this.listener) {
+            this.logger.warn('No listener registered, ignoring messages');
+            return;
+        }
+        for (const message of messages) {
+            const from = extractNumberFromWasenderMessageKey(message.key);
+            this.logger.trace(`new message from '${from}' to '${this.config.phoneNumber}'`);
+            if (message.message.conversation) {
+                const chatConnection = {
+                    chatType: 'PRIVATE',
+                    channelName: 'WhatsAppByWasenderChannel',
+                    id: from,
+                };
+                await this.listener({
+                    chatConnection,
+                    message: {
+                        text: message.message.conversation,
+                        senderName: message.pushName,
+                        senderId: from,
+                    },
+                });
+            }
+        }
+    }
+    async parseEvent(req, rawBody) {
+        const adapter = {
+            getHeader: (name) => req.header(name),
+            getRawBody: () => rawBody,
+        };
+        const event = await this.wasender.handleWebhookEvent(adapter);
+        return event;
+    }
+    getRawBody(req) {
+        return new Promise((resolve, reject) => {
+            let data = '';
+            req.on('data', (chunk) => {
+                data += chunk;
+            });
+            req.on('end', () => {
+                resolve(data);
+            });
+            req.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+};
+WhatsAppReceiverByWasender = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [ExpressProvider,
+        WhatsAppByWasenderChannelConfig])
+], WhatsAppReceiverByWasender);
+
+export { WhatsAppReceiverByWasender };

package/dist/src/addon/chat-controller/whatsapp-by-wasender/WhatsAppSenderByWasender.js

@@ -0,0 +1,40 @@
+import { __decorate, __metadata } from 'tslib';
+import { Logger } from '../../../core/logger/Logger.js';
+import { injectable } from '../../../core/injection/index.js';
+import { createWasender } from '../../../node_modules/wasenderapi/dist/index.js';
+import { WhatsAppByWasenderChannelConfig } from './WhatsAppByWasenderChannelConfig.js';
+
+let WhatsAppSenderByWasender = class WhatsAppSenderByWasender {
+    wasender;
+    logger = new Logger('wabot:whatsapp-sender-by-wasender');
+    constructor(config) {
+        this.wasender = createWasender(config.apiKey, undefined, undefined, undefined, config.retryOptions, undefined);
+    }
+    async send(request) {
+        try {
+            const textPayload = {
+                messageType: 'text',
+                to: `+${request.to.replace(/\D+/g, '')}`,
+                text: request.message.text ?? 'No Text',
+            };
+            const result = await this.wasender.send(textPayload);
+            this.logger.trace(`message sent from '${request.from}' to '${request.to}'`);
+            this.logger.trace(`rate limit remaining: ${result.rateLimit?.remaining}`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to send message from '${request.from}' to '${request.to}'`, error);
+            if (error instanceof Error) {
+                throw new Error(error.message, { cause: error });
+            }
+            else {
+                throw new Error('error sending message');
+            }
+        }
+    }
+};
+WhatsAppSenderByWasender = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [WhatsAppByWasenderChannelConfig])
+], WhatsAppSenderByWasender);
+
+export { WhatsAppSenderByWasender };

package/dist/src/addon/chat-controller/whatsapp-by-wasender/extractNumberFromWasenderKey.js

@@ -0,0 +1,5 @@
+function extractNumberFromWasenderMessageKey(key) {
+    return key.cleanedSenderPn ?? key.senderPn?.split('@')?.at(0) ?? key.remoteJid.split('@').at(0);
+}
+
+export { extractNumberFromWasenderMessageKey };

package/dist/src/feature/chat-bot/extractChatMessageText.js

@@ -0,0 +1,13 @@
+function extractChatMessageText(message) {
+    const messageData = {
+        senderId: message.senderId,
+        senderName: message.senderName,
+        text: message.text,
+        object: message.object,
+        metadata: message.metadata,
+        images: message.images?.map((x) => ({ id: x.id, name: x.name })),
+    };
+    return JSON.stringify(messageData);
+}
+
+export { extractChatMessageText };

package/dist/src/feature/rest-controller/metadata/RestControllerMetadataStore.js

@@ -1,6 +1,15 @@
 import { __decorate } from 'tslib';
 import { singleton } from '../../../core/injection/index.js';
 
+function getClassHierarchy(cls) {
+    const classes = [];
+    let proto = Object.getPrototypeOf(cls.prototype);
+    while (proto && proto.constructor !== Object) {
+        classes.push(proto.constructor);
+        proto = Object.getPrototypeOf(proto);
+    }
+    return classes;
+}
 let RestControllerMetadataStore = class RestControllerMetadataStore {
     endPoints = new Map();
     middlewares = new Map();
@@ -31,16 +40,34 @@ let RestControllerMetadataStore = class RestControllerMetadataStore {
         if (!controller) {
             throw new Error(`${controllerConstructor.name} should be decorated with @restController`);
         }
-        const endPoints = this.endPoints.get(controllerConstructor);
-        if (!endPoints?.size) {
-            // TODO: Warning
+        const hierarchy = [controllerConstructor, ...getClassHierarchy(controllerConstructor)];
+        const endPointsMap = new Map();
+        for (const cls of [...hierarchy].reverse()) {
+            const classEndPoints = this.endPoints.get(cls);
+            if (classEndPoints) {
+                for (const [name, endPoint] of classEndPoints) {
+                    endPointsMap.set(name, endPoint);
+                }
+            }
+        }
+        if (!endPointsMap.size) {
             return [];
         }
-        return [...endPoints.values()].map((endPoint) => ({
-            ...endPoint,
-            middlewares: this.middlewares.get(endPoint.controllerConstructor)?.get(endPoint.functionName) ?? [],
-            controller: this.restControllers.get(endPoint.controllerConstructor),
-        }));
+        return [...endPointsMap.values()].map((endPoint) => {
+            const middlewares = [];
+            for (const cls of [...hierarchy].reverse()) {
+                const classMiddlewares = this.middlewares.get(cls)?.get(endPoint.functionName);
+                if (classMiddlewares) {
+                    middlewares.push(...classMiddlewares);
+                }
+            }
+            return {
+                ...endPoint,
+                controllerConstructor,
+                middlewares,
+                controller,
+            };
+        });
     }
 };
 RestControllerMetadataStore = __decorate([