@grupodiariodaregiao/bunstone 0.4.1 → 0.4.3

package/dist/index.d.ts

@@ -55,6 +55,7 @@ export * from "./lib/jwt";
 export * from "./lib/jwt/jwt-module";
 export { JwtService } from "./lib/jwt/jwt.service";
 export * from "./lib/module";
+export * from "./lib/on-module";
 export * from "./lib/openapi";
 export * from "./lib/render";
 export * from "./lib/types/options";

package/dist/index.js

@@ -116627,6 +116627,14 @@ function Head2(pathname = "") {
   return HttpMethodDecorator("HEAD", pathname);
 }
 
+// lib/on-module/on-module-destroy.ts
+class OnModuleDestroy {
+}
+
+// lib/on-module/on-module-init.ts
+class OnModuleInit {
+}
+
 // lib/openapi.ts
 var import_reflect_metadata13 = __toESM(require_Reflect(), 1);
 var API_TAGS_METADATA = "dip:openapi:tags";
@@ -117086,12 +117094,22 @@ class AppStartup {
   static elysia = new Elysia;
   static logger = new Logger(AppStartup.name);
   static registeredSagas = new WeakSet;
+  static initializedModuleHooks = new WeakSet;
+  static destroyedModuleHooks = new WeakSet;
+  static destroyPromise = null;
+  static hasBeenDestroyed = false;
+  static rootModule;
   static viewBundles = new Map;
   static globalRateLimitConfig;
   static rateLimitService = new RateLimitService;
   static async create(module, options) {
     try {
       AppStartup.elysia = new Elysia;
+      AppStartup.rootModule = module;
+      AppStartup.initializedModuleHooks = new WeakSet;
+      AppStartup.destroyedModuleHooks = new WeakSet;
+      AppStartup.destroyPromise = null;
+      AppStartup.hasBeenDestroyed = false;
       const publicExists = await Bun.file("public").exists();
       if (!publicExists)
         await mkdir("./public", { recursive: true });
@@ -117144,6 +117162,9 @@ class AppStartup {
           message: error48 instanceof Error ? error48.message : "Internal Server Error"
         };
       });
+      AppStartup.elysia.onStop(async () => {
+        await AppStartup.executeDestroyLifecycle();
+      });
       if (options?.cors) {
         AppStartup.elysia.use(cors(options.cors));
       }
@@ -117181,7 +117202,7 @@ class AppStartup {
         }));
       }
       AppStartup.globalRateLimitConfig = options?.rateLimit;
-      AppStartup.registerModules(module);
+      await AppStartup.registerModules(module);
       return {
         listen: AppStartup.listen,
         getElysia: () => AppStartup.elysia
@@ -117293,6 +117314,28 @@ if (document.readyState === 'loading') {
     AppStartup.logger.log(`App is running at http://localhost:${port}`);
     AppStartup.elysia.listen(port);
   }
+  static async executeDestroyLifecycle() {
+    if (!AppStartup.rootModule) {
+      return;
+    }
+    if (AppStartup.hasBeenDestroyed) {
+      return;
+    }
+    if (AppStartup.destroyPromise) {
+      await AppStartup.destroyPromise;
+      return;
+    }
+    AppStartup.destroyPromise = (async () => {
+      await AppStartup.destroyModules(AppStartup.rootModule);
+      AppStartup.hasBeenDestroyed = true;
+    })().catch((error48) => {
+      AppStartup.logger.error(`Error while executing OnModuleDestroy hooks: ${error48?.message || error48}`);
+      throw error48;
+    }).finally(() => {
+      AppStartup.destroyPromise = null;
+    });
+    await AppStartup.destroyPromise;
+  }
   static async executeControllerMethod(context, controller, method) {
     const args = await processParameters(context, controller, method);
     const result = await controller[method](...args);
@@ -117336,7 +117379,7 @@ if (document.readyState === 'loading') {
     }
     return result;
   }
-  static registerModules(module) {
+  static async registerModules(module) {
     const isGlobal = Reflect.getMetadata("dip:module:global", module);
     if (isGlobal) {
       const injectables = Reflect.getMetadata("dip:injectables", module);
@@ -117355,7 +117398,47 @@ if (document.readyState === 'loading') {
     AppStartup.registerRabbitMQConsumers(module);
     const modules = Reflect.getMetadata("dip:modules", module) || [];
     for (const mod of modules) {
-      AppStartup.registerModules(mod);
+      await AppStartup.registerModules(mod);
+    }
+    await AppStartup.executeOnModuleInit(module);
+  }
+  static async destroyModules(module) {
+    const modules = Reflect.getMetadata("dip:modules", module) || [];
+    for (const mod of modules) {
+      await AppStartup.destroyModules(mod);
+    }
+    await AppStartup.executeOnModuleDestroy(module);
+  }
+  static async executeOnModuleInit(module) {
+    const injectables = Reflect.getMetadata("dip:injectables", module);
+    if (!injectables) {
+      return;
+    }
+    for (const provider of injectables.values()) {
+      if (!(provider instanceof OnModuleInit)) {
+        continue;
+      }
+      if (AppStartup.initializedModuleHooks.has(provider)) {
+        continue;
+      }
+      AppStartup.initializedModuleHooks.add(provider);
+      await provider.onModuleInit();
+    }
+  }
+  static async executeOnModuleDestroy(module) {
+    const injectables = Reflect.getMetadata("dip:injectables", module);
+    if (!injectables) {
+      return;
+    }
+    for (const provider of injectables.values()) {
+      if (!(provider instanceof OnModuleDestroy)) {
+        continue;
+      }
+      if (AppStartup.destroyedModuleHooks.has(provider)) {
+        continue;
+      }
+      AppStartup.destroyedModuleHooks.add(provider);
+      await provider.onModuleDestroy();
     }
   }
   static registerRoutes(module) {
@@ -117583,6 +117666,33 @@ if (document.readyState === 'loading') {
       return;
     }
     const injectables = Reflect.getMetadata("dip:injectables", module);
+    function matchRoutingKey(pattern, routingKey) {
+      if (pattern === routingKey)
+        return true;
+      if (!pattern.includes("*") && !pattern.includes("#"))
+        return false;
+      const pp = pattern.split(".");
+      const kp = routingKey.split(".");
+      function go2(pi3, ki3) {
+        if (pi3 === pp.length && ki3 === kp.length)
+          return true;
+        if (pi3 === pp.length)
+          return false;
+        if (pp[pi3] === "#") {
+          for (let j4 = ki3;j4 <= kp.length; j4++) {
+            if (go2(pi3 + 1, j4))
+              return true;
+          }
+          return false;
+        }
+        if (ki3 === kp.length)
+          return false;
+        if (pp[pi3] === "*" || pp[pi3] === kp[ki3])
+          return go2(pi3 + 1, ki3 + 1);
+        return false;
+      }
+      return go2(0, 0);
+    }
     (async () => {
       try {
         await RabbitMQConnection.initialise();
@@ -117652,7 +117762,10 @@ if (document.readyState === 'loading') {
       }
       for (const [queue2, handlers] of queueMap.entries()) {
         const noAck = handlers.every((h3) => h3.noAck);
-        const handlerList = handlers.map((h3) => `${h3.providerName}.${h3.descriptor.methodName}()`).join(", ");
+        const handlerList = handlers.map((h3) => {
+          const rk = h3.descriptor.options.routingKey;
+          return `${h3.providerName}.${h3.descriptor.methodName}()${rk ? ` [${rk}]` : ""}`;
+        }).join(", ");
         AppStartup.logger.log(`Registering RabbitMQ consumer for queue: "${queue2}" \u2192 [${handlerList}]`);
         try {
           const channel = await RabbitMQConnection.getConsumerChannel(queue2);
@@ -117686,6 +117799,10 @@ if (document.readyState === 'loading') {
               noAck: handlerNoAck,
               providerName
             } of handlers) {
+              const handlerRoutingKey = descriptor.options.routingKey;
+              if (handlerRoutingKey && !matchRoutingKey(handlerRoutingKey, raw.fields.routingKey)) {
+                continue;
+              }
               try {
                 await instance[descriptor.methodName](msg);
               } catch (err) {
@@ -117695,6 +117812,9 @@ if (document.readyState === 'loading') {
                 }
               }
             }
+            if (!noAck && !settled) {
+              settle(() => channel.ack(raw));
+            }
           }, { noAck });
         } catch (err) {
           AppStartup.logger.error(`Failed to register consumer for queue "${queue2}": ${err.message}`);
@@ -119939,6 +120059,8 @@ export {
   ParamType,
   Param,
   Options,
+  OnModuleInit,
+  OnModuleDestroy,
   OkResponse,
   NotFoundException,
   NoContentResponse,

package/dist/lib/app-startup.d.ts

@@ -9,6 +9,11 @@ export declare class AppStartup {
     private static elysia;
     private static readonly logger;
     private static readonly registeredSagas;
+    private static initializedModuleHooks;
+    private static destroyedModuleHooks;
+    private static destroyPromise;
+    private static hasBeenDestroyed;
+    private static rootModule;
     private static readonly viewBundles;
     private static globalRateLimitConfig;
     private static rateLimitService;
@@ -67,8 +72,12 @@ export declare class AppStartup {
      * @param port The port number to listen on.
      */
     static listen(port: number): void;
+    private static executeDestroyLifecycle;
     private static executeControllerMethod;
     private static registerModules;
+    private static destroyModules;
+    private static executeOnModuleInit;
+    private static executeOnModuleDestroy;
     private static registerRoutes;
     /**
      * Builds effective rate limit configuration by merging global config with method config

package/dist/lib/on-module/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./on-module-destroy";
+export * from "./on-module-init";

package/dist/lib/on-module/on-module-destroy.d.ts

@@ -0,0 +1,3 @@
+export declare abstract class OnModuleDestroy {
+    abstract onModuleDestroy(): Promise<void> | void;
+}

package/dist/lib/on-module/on-module-init.d.ts

@@ -0,0 +1,3 @@
+export declare abstract class OnModuleInit {
+    abstract onModuleInit(): Promise<void> | void;
+}

package/lib/app-startup.ts

@@ -28,6 +28,8 @@ import { ConfigurationError } from "./errors";
 import { HttpException } from "./http-exceptions";
 import { HTTP_HEADERS_METADATA } from "./http-methods";
 import { ParamType, processParameters } from "./http-params";
+import { OnModuleDestroy } from "./on-module/on-module-destroy";
+import { OnModuleInit } from "./on-module/on-module-init";
 import {
 	API_HEADERS_METADATA,
 	API_OPERATION_METADATA,
@@ -57,6 +59,11 @@ export class AppStartup {
 	private static elysia: Elysia = new Elysia();
 	private static readonly logger = new Logger(AppStartup.name);
 	private static readonly registeredSagas = new WeakSet<any>();
+	private static initializedModuleHooks = new WeakSet<OnModuleInit>();
+	private static destroyedModuleHooks = new WeakSet<OnModuleDestroy>();
+	private static destroyPromise: Promise<void> | null = null;
+	private static hasBeenDestroyed = false;
+	private static rootModule: any;
 	private static readonly viewBundles = new Map<string, string>();
 	private static globalRateLimitConfig: RateLimitGlobalConfig | undefined;
 	private static rateLimitService: RateLimitService = new RateLimitService();
@@ -71,6 +78,11 @@ export class AppStartup {
 	static async create(module: any, options?: Options) {
 		try {
 			AppStartup.elysia = new Elysia(); // Reset for each creation
+			AppStartup.rootModule = module;
+			AppStartup.initializedModuleHooks = new WeakSet<OnModuleInit>();
+			AppStartup.destroyedModuleHooks = new WeakSet<OnModuleDestroy>();
+			AppStartup.destroyPromise = null;
+			AppStartup.hasBeenDestroyed = false;
 
 			const publicExists = await Bun.file("public").exists();
 			// Ensure public directory exists before static plugin uses it
@@ -149,6 +161,10 @@ export class AppStartup {
 				};
 			});
 
+			AppStartup.elysia.onStop(async () => {
+				await AppStartup.executeDestroyLifecycle();
+			});
+
 			if (options?.cors) {
 				AppStartup.elysia.use(cors(options.cors));
 			}
@@ -202,7 +218,7 @@ export class AppStartup {
 			// Store global rate limit config
 			AppStartup.globalRateLimitConfig = options?.rateLimit;
 
-			AppStartup.registerModules(module);
+			await AppStartup.registerModules(module);
 			return {
 				/**
 				 * Starts the server on the specified port.
@@ -352,6 +368,37 @@ if (document.readyState === 'loading') {
 		AppStartup.elysia.listen(port);
 	}
 
+	private static async executeDestroyLifecycle() {
+		if (!AppStartup.rootModule) {
+			return;
+		}
+
+		if (AppStartup.hasBeenDestroyed) {
+			return;
+		}
+
+		if (AppStartup.destroyPromise) {
+			await AppStartup.destroyPromise;
+			return;
+		}
+
+		AppStartup.destroyPromise = (async () => {
+			await AppStartup.destroyModules(AppStartup.rootModule);
+			AppStartup.hasBeenDestroyed = true;
+		})()
+			.catch((error) => {
+				AppStartup.logger.error(
+					`Error while executing OnModuleDestroy hooks: ${error?.message || error}`,
+				);
+				throw error;
+			})
+			.finally(() => {
+				AppStartup.destroyPromise = null;
+			});
+
+		await AppStartup.destroyPromise;
+	}
+
 	private static async executeControllerMethod(
 		context: any,
 		controller: any,
@@ -436,7 +483,7 @@ if (document.readyState === 'loading') {
 		return result;
 	}
 
-	private static registerModules(module: any) {
+	private static async registerModules(module: any) {
 		const isGlobal = Reflect.getMetadata("dip:module:global", module);
 		if (isGlobal) {
 			const injectables: Map<any, any> = Reflect.getMetadata(
@@ -461,7 +508,67 @@ if (document.readyState === 'loading') {
 		const modules = Reflect.getMetadata("dip:modules", module) || [];
 
 		for (const mod of modules) {
-			AppStartup.registerModules(mod);
+			await AppStartup.registerModules(mod);
+		}
+
+		await AppStartup.executeOnModuleInit(module);
+	}
+
+	private static async destroyModules(module: any) {
+		const modules = Reflect.getMetadata("dip:modules", module) || [];
+
+		for (const mod of modules) {
+			await AppStartup.destroyModules(mod);
+		}
+
+		await AppStartup.executeOnModuleDestroy(module);
+	}
+
+	private static async executeOnModuleInit(module: any) {
+		const injectables: Map<any, any> | undefined = Reflect.getMetadata(
+			"dip:injectables",
+			module,
+		);
+
+		if (!injectables) {
+			return;
+		}
+
+		for (const provider of injectables.values()) {
+			if (!(provider instanceof OnModuleInit)) {
+				continue;
+			}
+
+			if (AppStartup.initializedModuleHooks.has(provider)) {
+				continue;
+			}
+
+			AppStartup.initializedModuleHooks.add(provider);
+			await provider.onModuleInit();
+		}
+	}
+
+	private static async executeOnModuleDestroy(module: any) {
+		const injectables: Map<any, any> | undefined = Reflect.getMetadata(
+			"dip:injectables",
+			module,
+		);
+
+		if (!injectables) {
+			return;
+		}
+
+		for (const provider of injectables.values()) {
+			if (!(provider instanceof OnModuleDestroy)) {
+				continue;
+			}
+
+			if (AppStartup.destroyedModuleHooks.has(provider)) {
+				continue;
+			}
+
+			AppStartup.destroyedModuleHooks.add(provider);
+			await provider.onModuleDestroy();
 		}
 	}
 
@@ -879,6 +986,34 @@ if (document.readyState === 'loading') {
 			module,
 		);
 
+		/**
+		 * Matches a RabbitMQ topic routing key pattern against a concrete routing key.
+		 * Supports `*` (exactly one word) and `#` (zero or more words).
+		 */
+		function matchRoutingKey(pattern: string, routingKey: string): boolean {
+			if (pattern === routingKey) return true;
+			if (!pattern.includes("*") && !pattern.includes("#")) return false;
+
+			const pp = pattern.split(".");
+			const kp = routingKey.split(".");
+
+			function go(pi: number, ki: number): boolean {
+				if (pi === pp.length && ki === kp.length) return true;
+				if (pi === pp.length) return false;
+				if (pp[pi] === "#") {
+					for (let j = ki; j <= kp.length; j++) {
+						if (go(pi + 1, j)) return true;
+					}
+					return false;
+				}
+				if (ki === kp.length) return false;
+				if (pp[pi] === "*" || pp[pi] === kp[ki]) return go(pi + 1, ki + 1);
+				return false;
+			}
+
+			return go(0, 0);
+		}
+
 		type QueueHandler = {
 			instance: any;
 			descriptor: RabbitMQMethodDescriptor;
@@ -995,7 +1130,10 @@ if (document.readyState === 'loading') {
 				const noAck = handlers.every((h) => h.noAck);
 
 				const handlerList = handlers
-					.map((h) => `${h.providerName}.${h.descriptor.methodName}()`)
+					.map((h) => {
+						const rk = h.descriptor.options.routingKey;
+						return `${h.providerName}.${h.descriptor.methodName}()${rk ? ` [${rk}]` : ""}`;
+					})
 					.join(", ");
 
 				AppStartup.logger.log(
@@ -1043,6 +1181,17 @@ if (document.readyState === 'loading') {
 								noAck: handlerNoAck,
 								providerName,
 							} of handlers) {
+								// ── Routing-key filter ─────────────────────────────────────────────
+								// When { queue, routingKey } is set without exchange, only dispatch
+								// if the message's routing key matches the declared pattern.
+								const handlerRoutingKey = descriptor.options.routingKey;
+								if (
+									handlerRoutingKey &&
+									!matchRoutingKey(handlerRoutingKey, raw.fields.routingKey)
+								) {
+									continue;
+								}
+
 								try {
 									await instance[descriptor.methodName](msg);
 								} catch (err: any) {
@@ -1054,6 +1203,13 @@ if (document.readyState === 'loading') {
 									}
 								}
 							}
+
+							// ── Auto-ack if no handler consumed the message ────────────────
+							// All handlers were filtered out by routingKey – ack silently
+							// to prevent the message from piling up as unacked.
+							if (!noAck && !settled) {
+								settle(() => channel.ack(raw));
+							}
 						},
 						{ noAck },
 					);

package/lib/on-module/index.ts

@@ -0,0 +1,2 @@
+export * from "./on-module-destroy";
+export * from "./on-module-init";

package/lib/on-module/on-module-destroy.ts

@@ -0,0 +1,3 @@
+export abstract class OnModuleDestroy {
+	abstract onModuleDestroy(): Promise<void> | void;
+}

package/lib/on-module/on-module-init.ts

@@ -0,0 +1,3 @@
+export abstract class OnModuleInit {
+	abstract onModuleInit(): Promise<void> | void;
+}

package/package.json

@@ -13,7 +13,7 @@
       "types": "./dist/*.d.ts"
     }
   },
-  "version": "0.4.1",
+  "version": "0.4.3",
   "homepage": "https://bunstone.diario.one/",
   "repository": {
     "url": "https://github.com/diariodaregiao/bunstone.git",