@grupodiariodaregiao/bunstone 0.4.2 → 0.4.4

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

@@ -117086,12 +117086,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 +117154,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 +117194,7 @@ class AppStartup {
         }));
       }
       AppStartup.globalRateLimitConfig = options?.rateLimit;
-      AppStartup.registerModules(module);
+      await AppStartup.registerModules(module);
       return {
         listen: AppStartup.listen,
         getElysia: () => AppStartup.elysia
@@ -117293,6 +117306,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 +117371,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,8 +117390,52 @@ 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 (AppStartup.initializedModuleHooks.has(provider)) {
+        continue;
+      }
+      if (AppStartup.hasOnModuleInit(provider)) {
+        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 (AppStartup.destroyedModuleHooks.has(provider)) {
+        continue;
+      }
+      if (AppStartup.hasOnModuleDestroy(provider)) {
+        AppStartup.destroyedModuleHooks.add(provider);
+        await provider.onModuleDestroy();
+      }
+    }
+  }
+  static hasOnModuleInit(provider) {
+    return !!provider && typeof provider.onModuleInit === "function";
+  }
+  static hasOnModuleDestroy(provider) {
+    return !!provider && typeof provider.onModuleDestroy === "function";
   }
   static registerRoutes(module) {
     const controllers = Reflect.getMetadata("dip:module:routes", module);

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,14 @@ 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 hasOnModuleInit;
+    private static hasOnModuleDestroy;
     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 interface OnModuleDestroy {
+    onModuleDestroy(): Promise<void> | void;
+}

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

@@ -0,0 +1,3 @@
+export interface OnModuleInit {
+    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 type { OnModuleDestroy } from "./on-module/on-module-destroy";
+import type { 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,8 +508,74 @@ 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 (AppStartup.initializedModuleHooks.has(provider)) {
+				continue;
+			}
+
+			if (AppStartup.hasOnModuleInit(provider)) {
+				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 (AppStartup.destroyedModuleHooks.has(provider)) {
+				continue;
+			}
+
+			if (AppStartup.hasOnModuleDestroy(provider)) {
+				AppStartup.destroyedModuleHooks.add(provider);
+				await provider.onModuleDestroy();
+			}
+		}
+	}
+
+	private static hasOnModuleInit(provider: any): provider is OnModuleInit {
+		return !!provider && typeof provider.onModuleInit === "function";
+	}
+
+	private static hasOnModuleDestroy(
+		provider: any,
+	): provider is OnModuleDestroy {
+		return !!provider && typeof provider.onModuleDestroy === "function";
 	}
 
 	private static registerRoutes(module: any) {

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 interface OnModuleDestroy {
+	onModuleDestroy(): Promise<void> | void;
+}

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

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

package/package.json

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