@autowired-framework/core 0.0.1

package/dist/dependency-injection/injector.d.ts

@@ -0,0 +1,67 @@
+import "reflect-metadata";
+/**
+ * Enum representing the Scope of a component.
+ */
+export declare enum Scope {
+    Singleton = "Singleton",
+    Request = "Request"
+}
+/**
+ * Injector class manages dependency registration and retrieval.
+ */
+export declare class InjectorClass {
+    private singletons;
+    private instances;
+    private resolving;
+    private autoWire;
+    /**
+     * Resolves a singleton instance.
+     * @param target - The class constructor to instantiate.
+     * @returns {T} - The instantiated singleton.
+     *
+     * @implementationNote
+     * This method handles instantiation of singletons, ensuring that dependencies are resolved recursively.
+     */
+    private resolveSingleton;
+    /**
+     * Retrieves an instance by token or class constructor.
+     * @param token - The token (symbol or constructor) to retrieve the instance for.
+     * @returns {T} - The instance associated with the token.
+     * @throws Will throw an error if no instance is found or if a circular dependency is detected.
+     */
+    getInstance<T>(token: Function | symbol): T;
+    /**
+     * Registers an existing instance with a specific token.
+     * @param token - The token to register the instance under.
+     * @param instance - The instance to associate with the token.
+     */
+    registerInstance(token: symbol, instance: any): void;
+    /**
+     * Checks if a component is already registered.
+     * @param token - The token (symbol or constructor) to check.
+     * @returns {boolean} - True if registered, false otherwise.
+     */
+    isRegistered(token: Function | symbol): boolean;
+    /**
+     * Registers a class as a singleton.
+     * @param target - The class constructor to register.
+     */
+    registerSingleton(target: Function): void;
+    /**
+     * Clears all registered instances and singletons.
+     * Useful for testing to ensure clean state between tests.
+     */
+    clear(): void;
+    /**
+     * Sets the autoWire flag for the injector.
+     * When autoWire is true, the injector will attempt to automatically
+     * instantiate and register unregistered class constructors.
+     * @param flag - Enable or disable auto-wiring.
+     */
+    setAutoWire(flag: boolean): void;
+}
+/**
+ * Singleton instance of the Injector.
+ */
+export declare const Injector: InjectorClass;
+export type InjectorType = InjectorClass;

package/dist/dependency-injection/injector.js

@@ -0,0 +1,165 @@
+"use strict";
+// src/core/dependency-injection/injector.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Injector = exports.InjectorClass = exports.Scope = void 0;
+require("reflect-metadata");
+const symbols_1 = require("../symbols");
+const decorator_factory_1 = require("../decorators/decorator-factory");
+/**
+ * Enum representing the Scope of a component.
+ */
+var Scope;
+(function (Scope) {
+    Scope["Singleton"] = "Singleton";
+    Scope["Request"] = "Request"; // Future use
+})(Scope || (exports.Scope = Scope = {}));
+/**
+ * Injector class manages dependency registration and retrieval.
+ */
+class InjectorClass {
+    constructor() {
+        this.singletons = new Map();
+        this.instances = new Map();
+        this.resolving = new Set();
+        this.autoWire = false;
+    }
+    /**
+     * Resolves a singleton instance.
+     * @param target - The class constructor to instantiate.
+     * @returns {T} - The instantiated singleton.
+     *
+     * @implementationNote
+     * This method handles instantiation of singletons, ensuring that dependencies are resolved recursively.
+     */
+    resolveSingleton(target) {
+        if (this.singletons.has(target)) {
+            const existingInstance = this.singletons.get(target);
+            if (existingInstance && typeof existingInstance !== "function") {
+                return existingInstance;
+            }
+        }
+        if (this.resolving.has(target)) {
+            const chain = Array.from(this.resolving)
+                .map(t => t.name)
+                .join(" -> ");
+            throw new Error(`Injector: Circular dependency detected: ${chain} -> ${target.name}`);
+        }
+        this.resolving.add(target);
+        try {
+            // Resolve constructor dependencies
+            const paramTypes = Reflect.getMetadata(symbols_1.BUILT_IN_PARAMETER_TYPE_METADATA, target) || [];
+            const dependencies = paramTypes.map(param => {
+                if (param === Object) {
+                    throw new Error(`Injector: Failed to resolve dependency for ${target.name}. Did you forget to use @Service or @Repository decorator?`);
+                }
+                return this.getInstance(param);
+            });
+            // Instantiate the class with dependencies
+            const instance = new target(...dependencies);
+            // Inject autowired properties (lazy property injection)
+            // This must happen after construction, so dependencies are available
+            decorator_factory_1.DecoratorFactory.injectAutowiredProperties(instance, target);
+            // Register the singleton instance
+            this.singletons.set(target, instance);
+            return instance;
+        }
+        finally {
+            this.resolving.delete(target);
+        }
+    }
+    /**
+     * Retrieves an instance by token or class constructor.
+     * @param token - The token (symbol or constructor) to retrieve the instance for.
+     * @returns {T} - The instance associated with the token.
+     * @throws Will throw an error if no instance is found or if a circular dependency is detected.
+     */
+    getInstance(token) {
+        const tokenName = typeof token === "function" ? token.name : token.toString();
+        // Check if an instance is registered directly via symbol
+        if (typeof token === "symbol") {
+            if (this.instances.has(token)) {
+                return this.instances.get(token);
+            }
+            else {
+                throw new Error(`Injector: No instance registered for token: ${tokenName}`);
+            }
+        }
+        // Check for singleton registration via class constructor
+        if (typeof token === "function") {
+            if (this.singletons.has(token)) {
+                const cached = this.singletons.get(token);
+                // If the cached value is a constructor, we need to resolve it (first access)
+                if (cached && typeof cached === "function") {
+                    return this.resolveSingleton(cached);
+                }
+                else {
+                    // Return the cached instance directly (subsequent accesses)
+                    return cached;
+                }
+            }
+            else {
+                // Auto-wiring: automatically register and resolve if enabled
+                if (this.autoWire) {
+                    this.registerSingleton(token);
+                    return this.resolveSingleton(token);
+                }
+                throw new Error(`Injector: No provider found for token: ${tokenName}. Did you forget to use @Service or @Repository?`);
+            }
+        }
+        throw new Error(`Injector: No provider found for token: ${tokenName}`);
+    }
+    /**
+     * Registers an existing instance with a specific token.
+     * @param token - The token to register the instance under.
+     * @param instance - The instance to associate with the token.
+     */
+    registerInstance(token, instance) {
+        if (!this.instances.has(token)) {
+            this.instances.set(token, instance);
+        }
+    }
+    /**
+     * Checks if a component is already registered.
+     * @param token - The token (symbol or constructor) to check.
+     * @returns {boolean} - True if registered, false otherwise.
+     */
+    isRegistered(token) {
+        if (typeof token === "symbol") {
+            return this.instances.has(token);
+        }
+        return this.singletons.has(token);
+    }
+    /**
+     * Registers a class as a singleton.
+     * @param target - The class constructor to register.
+     */
+    registerSingleton(target) {
+        if (!this.singletons.has(target)) {
+            this.singletons.set(target, target);
+        }
+    }
+    /**
+     * Clears all registered instances and singletons.
+     * Useful for testing to ensure clean state between tests.
+     */
+    clear() {
+        this.singletons.clear();
+        this.instances.clear();
+        this.resolving.clear();
+    }
+    /**
+     * Sets the autoWire flag for the injector.
+     * When autoWire is true, the injector will attempt to automatically
+     * instantiate and register unregistered class constructors.
+     * @param flag - Enable or disable auto-wiring.
+     */
+    setAutoWire(flag) {
+        this.autoWire = flag;
+    }
+}
+exports.InjectorClass = InjectorClass;
+/**
+ * Singleton instance of the Injector.
+ */
+exports.Injector = new InjectorClass();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"injector.js","sourceRoot":"","sources":["../../src/dependency-injection/injector.ts"],"names":[],"mappings":"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","sourcesContent":["// src/core/dependency-injection/injector.ts\n\nimport \"reflect-metadata\";\nimport { BUILT_IN_PARAMETER_TYPE_METADATA } from \"../symbols\";\nimport { DecoratorFactory } from \"../decorators/decorator-factory\";\n\n/**\n * Enum representing the Scope of a component.\n */\nexport enum Scope {\n  Singleton = \"Singleton\",\n  Request = \"Request\" // Future use\n}\n\n/**\n * Injector class manages dependency registration and retrieval.\n */\nexport class InjectorClass {\n  private singletons: Map<Function, any> = new Map();\n  private instances: Map<symbol, any> = new Map();\n  private resolving: Set<Function> = new Set();\n  private autoWire: boolean = false;\n\n  /**\n   * Resolves a singleton instance.\n   * @param target - The class constructor to instantiate.\n   * @returns {T} - The instantiated singleton.\n   *\n   * @implementationNote\n   * This method handles instantiation of singletons, ensuring that dependencies are resolved recursively.\n   */\n   private resolveSingleton<T>(target: Function): T {\n     if (this.singletons.has(target)) {\n       const existingInstance = this.singletons.get(target);\n       if (existingInstance && typeof existingInstance !== \"function\") {\n         return existingInstance;\n       }\n     }\n\n     if (this.resolving.has(target)) {\n       const chain = Array.from(this.resolving)\n         .map(t => t.name)\n         .join(\" -> \");\n       throw new Error(`Injector: Circular dependency detected: ${chain} -> ${target.name}`);\n     }\n\n     this.resolving.add(target);\n\n      try {\n        // Resolve constructor dependencies\n        const paramTypes: Function[] = Reflect.getMetadata(BUILT_IN_PARAMETER_TYPE_METADATA, target) || [];\n\n        const dependencies = paramTypes.map(param => {\n          if (param === Object) {\n            throw new Error(\n              `Injector: Failed to resolve dependency for ${target.name}. Did you forget to use @Service or @Repository decorator?`\n            );\n          }\n          return this.getInstance<any>(param);\n        });\n\n        // Instantiate the class with dependencies\n        const instance = new (target as any)(...dependencies);\n\n        // Inject autowired properties (lazy property injection)\n        // This must happen after construction, so dependencies are available\n        DecoratorFactory.injectAutowiredProperties(instance, target);\n\n        // Register the singleton instance\n        this.singletons.set(target, instance);\n\n        return instance;\n      } finally {\n        this.resolving.delete(target);\n      }\n   }\n\n  /**\n   * Retrieves an instance by token or class constructor.\n   * @param token - The token (symbol or constructor) to retrieve the instance for.\n   * @returns {T} - The instance associated with the token.\n   * @throws Will throw an error if no instance is found or if a circular dependency is detected.\n   */\n  public getInstance<T>(token: Function | symbol): T {\n    const tokenName = typeof token === \"function\" ? token.name : token.toString();\n\n    // Check if an instance is registered directly via symbol\n    if (typeof token === \"symbol\") {\n      if (this.instances.has(token)) {\n        return this.instances.get(token);\n      } else {\n        throw new Error(`Injector: No instance registered for token: ${tokenName}`);\n      }\n    }\n\n    // Check for singleton registration via class constructor\n    if (typeof token === \"function\") {\n      if (this.singletons.has(token)) {\n        const cached = this.singletons.get(token);\n        // If the cached value is a constructor, we need to resolve it (first access)\n        if (cached && typeof cached === \"function\") {\n          return this.resolveSingleton<T>(cached);\n        } else {\n          // Return the cached instance directly (subsequent accesses)\n          return cached;\n        }\n      } else {\n        // Auto-wiring: automatically register and resolve if enabled\n        if (this.autoWire) {\n          this.registerSingleton(token);\n          return this.resolveSingleton<T>(token);\n        }\n        throw new Error(\n          `Injector: No provider found for token: ${tokenName}. Did you forget to use @Service or @Repository?`\n        );\n      }\n    }\n\n    throw new Error(`Injector: No provider found for token: ${tokenName}`);\n  }\n\n   /**\n    * Registers an existing instance with a specific token.\n    * @param token - The token to register the instance under.\n    * @param instance - The instance to associate with the token.\n    */\n  public registerInstance(token: symbol, instance: any): void {\n    if (!this.instances.has(token)) {\n      this.instances.set(token, instance);\n    }\n  }\n\n  /**\n   * Checks if a component is already registered.\n   * @param token - The token (symbol or constructor) to check.\n   * @returns {boolean} - True if registered, false otherwise.\n   */\n  public isRegistered(token: Function | symbol): boolean {\n    if (typeof token === \"symbol\") {\n      return this.instances.has(token);\n    }\n    return this.singletons.has(token);\n  }\n\n  /**\n   * Registers a class as a singleton.\n   * @param target - The class constructor to register.\n   */\n  public registerSingleton(target: Function): void {\n    if (!this.singletons.has(target)) {\n      this.singletons.set(target, target);\n    }\n  }\n\n   /**\n    * Clears all registered instances and singletons.\n    * Useful for testing to ensure clean state between tests.\n    */\n  public clear(): void {\n    this.singletons.clear();\n    this.instances.clear();\n    this.resolving.clear();\n  }\n\n  /**\n   * Sets the autoWire flag for the injector.\n   * When autoWire is true, the injector will attempt to automatically\n   * instantiate and register unregistered class constructors.\n   * @param flag - Enable or disable auto-wiring.\n   */\n  public setAutoWire(flag: boolean): void {\n    this.autoWire = flag;\n  }\n}\n\n/**\n * Singleton instance of the Injector.\n */\nexport const Injector = new InjectorClass();\n\nexport type InjectorType = InjectorClass;\n"]}

package/dist/hooks/decorators/hook.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Valid lifecycle events for Controller request handling.
+ */
+export type RequestHooks = "preSerialization" | "preValidation" | "preParsing" | "preHandler" | "onResponse" | "onRequest" | "onTimeout" | "onError" | "onSend";
+/**
+ * Decorator to register a method as a controller request lifecycle hook.
+ * @param name - The name of the controller lifecycle event.
+ * @deprecated Use controller-specific hook decorators (@OnRequest, @PreHandler, etc.) instead.
+ * This global hook decorator will be removed in a future version.
+ */
+export declare const Hook: (name: RequestHooks) => MethodDecorator;

package/dist/hooks/decorators/hook.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hook = void 0;
+const registries_1 = require("../registry/registries");
+/**
+ * Decorator to register a method as a controller request lifecycle hook.
+ * @param name - The name of the controller lifecycle event.
+ * @deprecated Use controller-specific hook decorators (@OnRequest, @PreHandler, etc.) instead.
+ * This global hook decorator will be removed in a future version.
+ */
+const Hook = (name) => (target, propertyKey, descriptor) => {
+    if (!descriptor) {
+        throw new Error("@Hook can only be applied to methods.");
+    }
+    const handler = descriptor.value;
+    if (typeof handler !== "function") {
+        throw new Error("@Hook can only be applied to functions.");
+    }
+    // Register the hook directly in the registry
+    registries_1.requestHooksRegistry.register(name, handler.bind(target));
+};
+exports.Hook = Hook;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/hooks/decorators/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./lifecycle-hooks";
+export * from "./hook";

package/dist/hooks/decorators/index.js

@@ -0,0 +1,20 @@
+"use strict";
+// src/core/decorators/index.ts
+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 __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("./lifecycle-hooks"), exports);
+__exportStar(require("./hook"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaG9va3MvZGVjb3JhdG9ycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsK0JBQStCOzs7Ozs7Ozs7Ozs7Ozs7O0FBRS9CLG9EQUFrQztBQUNsQyx5Q0FBdUIiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBzcmMvY29yZS9kZWNvcmF0b3JzL2luZGV4LnRzXG5cbmV4cG9ydCAqIGZyb20gXCIuL2xpZmVjeWNsZS1ob29rc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vaG9va1wiO1xuIl19

package/dist/hooks/decorators/lifecycle-hooks.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Valid lifecycle events for Fastify lifecycle and autowired initialization.
+ */
+export type LifecycleHooks = "PLUGIN_REGISTRATION" | "APP_DESTROY" | "APP_READY" | "APP_START";
+export declare const ApplicationStart: () => MethodDecorator;
+export declare const PluginRegistration: () => MethodDecorator;
+export declare const LifecycleHooks: (hook: LifecycleHooks, decoratorName?: string) => MethodDecorator;

package/dist/hooks/decorators/lifecycle-hooks.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifecycleHooks = exports.PluginRegistration = exports.ApplicationStart = void 0;
+const registries_1 = require("../registry/registries");
+const ApplicationStart = () => (target, propertyKey, descriptor) => {
+    if (registries_1.lifecycleHooksRegistry.hasHandler("APP_START")) {
+        throw new Error("@ApplicationStart can only be registered once.");
+    }
+    (0, exports.LifecycleHooks)("APP_START", "@ApplicationStart")(target, propertyKey, descriptor);
+};
+exports.ApplicationStart = ApplicationStart;
+const PluginRegistration = () => (target, propertyKey, descriptor) => {
+    (0, exports.LifecycleHooks)("PLUGIN_REGISTRATION", "@PluginRegistration")(target, propertyKey, descriptor);
+};
+exports.PluginRegistration = PluginRegistration;
+const LifecycleHooks = (hook, decoratorName = "@LifecycleHook") => (target, propertyKey, descriptor) => {
+    if (!descriptor) {
+        throw new Error(`${decoratorName} can only be applied to methods.`);
+    }
+    const handler = descriptor.value;
+    if (typeof handler !== "function") {
+        throw new Error(`${decoratorName} can only be applied to functions.`);
+    }
+    registries_1.lifecycleHooksRegistry.register(hook, handler.bind(target));
+};
+exports.LifecycleHooks = LifecycleHooks;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/hooks/initialization.js

@@ -0,0 +1,70 @@
+"use strict";
+// // src/web/hooks/initialization.ts
+//
+// import { lifecycleHooksRegistry } from "@core/registry/hooks.registry";
+// import { Injector } from "@core/dependency-injection/injector";
+// import { FastifyInstance } from "fastify";
+//
+// import { classLoaderFactory, patchMethods } from "../utils/container.utils";
+//
+// /**
+//  * Hook: appInitialization
+//  * Registers the Fastify instance and decorates it with a class loader.
+//  */
+// lifecycleHooksRegistry.register("appInitialization", (fastify: FastifyInstance) => {
+//   fastify.log.trace("Executing appInitialization hook");
+//   // Decorate Fastify with the class loader
+//   try {
+//     fastify.decorate("CLASS_LOADER", classLoaderFactory(Injector));
+//     fastify.log.trace("Fastify: Decorated with CLASS_LOADER");
+//   } catch (error) {
+//     fastify.log.error(error, "Fastify: Failed to decorate with CLASS_LOADER:");
+//   }
+// });
+//
+// /**
+//  * Hook: beforeControllerCreation
+//  * Patches controller methods, e.g., adding logging.
+//  */
+// lifecycleHooksRegistry.register("beforeControllerCreation", (fastifyInstance: FastifyInstance, target: Function) => {
+//   fastifyInstance.log.info(`Executing beforeControllerCreation hook for ${target.name}`);
+//   try {
+//     patchMethods(target.prototype); // Patch the prototype to affect all instances
+//     fastifyInstance.log.trace(`Patching methods for ${target.name} completed successfully`);
+//   } catch (error) {
+//     fastifyInstance.log.error(error, `Failed to patch methods for ${target.name}:`);
+//   }
+// });
+//
+// /**
+//  * Hook: afterControllerCreation
+//  * Performs additional setup after controller instantiation.
+//  */
+// lifecycleHooksRegistry.register(
+//   "afterControllerCreation",
+//   async (fastifyInstance: FastifyInstance, target: Function, instance: any) => {
+//     fastifyInstance.log.trace(`Executing afterControllerCreation hook for ${target.name}`);
+//     try {
+//       // Example: Initialize resources or perform additional setup
+//       if (typeof instance.initialize === "function") {
+//         await instance.initialize();
+//         fastifyInstance.log.trace(`Initialized resources for controller '${target.name}'`);
+//       }
+//
+//       // Example: Register controller-specific plugins or middleware
+//       if (Array.isArray(instance.plugins)) {
+//         for (const plugin of instance.plugins) {
+//           fastifyInstance.register(plugin);
+//           fastifyInstance.log.trace(`Registered plugin '${plugin.name}' for controller '${target.name}'`);
+//         }
+//       }
+//
+//       // Implementation Note: Allows controllers to define their own initialization logic
+//       // by implementing an `initialize` method or specifying plugins.
+//     } catch (error) {
+//       fastifyInstance.log.error(error, `Error in afterControllerInitialization hook for ${target.name}:`);
+//       throw error; // Optionally re-throw to prevent application from starting
+//     }
+//   }
+// );
+//# sourceMappingURL=data:application/json;base64,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

package/dist/hooks/registry/hook.registry.d.ts

@@ -0,0 +1,23 @@
+export declare class HookRegistry<T extends string> {
+    private readonly registry;
+    constructor(hookNames: T[]);
+    /**
+     * Execute all registered handlers for a specific hook.
+     * @param hookName - The name of the hook.
+     * @param args - Arguments to pass to the handlers.
+     */
+    execute(hookName: T, ...args: any[]): Promise<void>;
+    /**
+     * Register a hook function for a specific hook.
+     * @param hookName - The name of the hook.
+     * @param handler - The function to execute for this hook.
+     */
+    register(hookName: T, handler: (...args: any[]) => unknown): void;
+    hasHandler(hookName: T): boolean;
+    /**
+     * Get all handlers registered for a specific hook.
+     * @param hookName - The name of the hook.
+     * @returns Array of registered handlers.
+     */
+    getHandlers(hookName: T): Array<(...args: any[]) => unknown>;
+}

package/dist/hooks/registry/hook.registry.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookRegistry = void 0;
+class HookRegistry {
+    constructor(hookNames) {
+        this.registry = {};
+        // Initialize registry with empty arrays for each hook
+        for (const hookName of hookNames) {
+            this.registry[hookName] = [];
+        }
+    }
+    /**
+     * Execute all registered handlers for a specific hook.
+     * @param hookName - The name of the hook.
+     * @param args - Arguments to pass to the handlers.
+     */
+    async execute(hookName, ...args) {
+        if (!this.registry[hookName]) {
+            throw new Error(`Hook '${hookName}' is not a valid hook stage.`);
+        }
+        for (const handler of this.registry[hookName]) {
+            await handler(...args);
+        }
+    }
+    /**
+     * Register a hook function for a specific hook.
+     * @param hookName - The name of the hook.
+     * @param handler - The function to execute for this hook.
+     */
+    register(hookName, handler) {
+        if (!this.registry[hookName]) {
+            throw new Error(`Hook '${hookName}' is not a valid hook stage.`);
+        }
+        this.registry[hookName].push(handler);
+    }
+    hasHandler(hookName) {
+        const handlers = this.registry[hookName];
+        return handlers.length !== 0;
+    }
+    /**
+     * Get all handlers registered for a specific hook.
+     * @param hookName - The name of the hook.
+     * @returns Array of registered handlers.
+     */
+    getHandlers(hookName) {
+        return this.registry[hookName] || [];
+    }
+}
+exports.HookRegistry = HookRegistry;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/hooks/registry/registries.d.ts

@@ -0,0 +1,5 @@
+import { LifecycleHooks } from "../decorators/lifecycle-hooks";
+import { HookRegistry } from "./hook.registry";
+import { RequestHooks } from "../decorators/hook";
+export declare const lifecycleHooksRegistry: HookRegistry<LifecycleHooks>;
+export declare const requestHooksRegistry: HookRegistry<RequestHooks>;

package/dist/hooks/registry/registries.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestHooksRegistry = exports.lifecycleHooksRegistry = void 0;
+const hook_registry_1 = require("./hook.registry");
+exports.lifecycleHooksRegistry = new hook_registry_1.HookRegistry([
+    "PLUGIN_REGISTRATION",
+    "APP_DESTROY",
+    "APP_READY",
+    "APP_START"
+]);
+// Request Hooks Registry
+exports.requestHooksRegistry = new hook_registry_1.HookRegistry([
+    "preSerialization",
+    "preValidation",
+    "preParsing",
+    "preHandler",
+    "onResponse",
+    "onRequest",
+    "onTimeout",
+    "onError",
+    "onSend"
+]);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0cmllcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9ob29rcy9yZWdpc3RyeS9yZWdpc3RyaWVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUNBLG1EQUErQztBQUdsQyxRQUFBLHNCQUFzQixHQUFHLElBQUksNEJBQVksQ0FBaUI7SUFDckUscUJBQXFCO0lBQ3JCLGFBQWE7SUFDYixXQUFXO0lBQ1gsV0FBVztDQUNaLENBQUMsQ0FBQztBQUVILHlCQUF5QjtBQUNaLFFBQUEsb0JBQW9CLEdBQUcsSUFBSSw0QkFBWSxDQUFlO0lBQ2pFLGtCQUFrQjtJQUNsQixlQUFlO0lBQ2YsWUFBWTtJQUNaLFlBQVk7SUFDWixZQUFZO0lBQ1osV0FBVztJQUNYLFdBQVc7SUFDWCxTQUFTO0lBQ1QsUUFBUTtDQUNULENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IExpZmVjeWNsZUhvb2tzIH0gZnJvbSBcIi4uL2RlY29yYXRvcnMvbGlmZWN5Y2xlLWhvb2tzXCI7XG5pbXBvcnQgeyBIb29rUmVnaXN0cnkgfSBmcm9tIFwiLi9ob29rLnJlZ2lzdHJ5XCI7XG5pbXBvcnQgeyBSZXF1ZXN0SG9va3MgfSBmcm9tIFwiLi4vZGVjb3JhdG9ycy9ob29rXCI7XG5cbmV4cG9ydCBjb25zdCBsaWZlY3ljbGVIb29rc1JlZ2lzdHJ5ID0gbmV3IEhvb2tSZWdpc3RyeTxMaWZlY3ljbGVIb29rcz4oW1xuICBcIlBMVUdJTl9SRUdJU1RSQVRJT05cIixcbiAgXCJBUFBfREVTVFJPWVwiLFxuICBcIkFQUF9SRUFEWVwiLFxuICBcIkFQUF9TVEFSVFwiXG5dKTtcblxuLy8gUmVxdWVzdCBIb29rcyBSZWdpc3RyeVxuZXhwb3J0IGNvbnN0IHJlcXVlc3RIb29rc1JlZ2lzdHJ5ID0gbmV3IEhvb2tSZWdpc3RyeTxSZXF1ZXN0SG9va3M+KFtcbiAgXCJwcmVTZXJpYWxpemF0aW9uXCIsXG4gIFwicHJlVmFsaWRhdGlvblwiLFxuICBcInByZVBhcnNpbmdcIixcbiAgXCJwcmVIYW5kbGVyXCIsXG4gIFwib25SZXNwb25zZVwiLFxuICBcIm9uUmVxdWVzdFwiLFxuICBcIm9uVGltZW91dFwiLFxuICBcIm9uRXJyb3JcIixcbiAgXCJvblNlbmRcIlxuXSk7XG4iXX0=

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./symbols";
+export { ComponentScanner } from "./component-scanner";
+export * from "./decorators";
+export { DecoratorFactory } from "./decorators/decorator-factory";
+export { Injector, Scope } from "./dependency-injection/injector";
+export { lifecycleHooksRegistry, requestHooksRegistry, } from "./hooks/registry/registries";
+export { HookRegistry } from "./hooks/registry/hook.registry";
+export { Hook, RequestHooks, RequestHooks as RequestHook, } from "./hooks/decorators/hook";
+export { LifecycleHooks, ApplicationStart, PluginRegistration, } from "./hooks/decorators/lifecycle-hooks";
+export { MetadataUtils } from "./utils/metadata.utils";
+export { timedFunction } from "./utils/time.utils";
+export { printBanner } from "./utils/banner.utils";
+export { resolveCallerDirectory } from "./utils/path.utils";
+export type { Constructor } from "./types";
+export type { LifecycleHook } from "./lifecycle/lifecycle.interface";