@nest-forge/core 0.0.2 → 0.0.3

package/dist/constants.d.ts

@@ -1,3 +1,6 @@
 export declare const FORGE_ROOT_MODULE: unique symbol;
 export declare const FORGE_FIELD_MODULE_REF: unique symbol;
 export declare const FORGE_TOKEN_ROOT_MODULE: unique symbol;
+export declare const FORGE_PATCHED: unique symbol;
+export declare const FORGE_PATCH_BOOT_CALLBACK: unique symbol;
+export declare const FORGE_PATCH_ENABLE_INIT: unique symbol;

package/dist/constants.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FORGE_TOKEN_ROOT_MODULE = exports.FORGE_FIELD_MODULE_REF = exports.FORGE_ROOT_MODULE = void 0;
+exports.FORGE_PATCH_ENABLE_INIT = exports.FORGE_PATCH_BOOT_CALLBACK = exports.FORGE_PATCHED = exports.FORGE_TOKEN_ROOT_MODULE = exports.FORGE_FIELD_MODULE_REF = exports.FORGE_ROOT_MODULE = void 0;
 exports.FORGE_ROOT_MODULE = Symbol('FORGE_ROOT_MODULE');
 exports.FORGE_FIELD_MODULE_REF = Symbol('FORGE_FIELD_MODULE_REF');
 exports.FORGE_TOKEN_ROOT_MODULE = Symbol('FORGE_TOKEN_ROOT_MODULE');
+exports.FORGE_PATCHED = Symbol('FORGE_PATCHED');
+exports.FORGE_PATCH_BOOT_CALLBACK = Symbol('FORGE_PATCH_BOOT_CALLBACK');
+exports.FORGE_PATCH_ENABLE_INIT = Symbol('FORGE_PATCH_ENABLE_INIT');

package/dist/extensions/extension.d.ts

@@ -1,5 +1,8 @@
-import { INestApplication, INestApplicationContext, INestMicroservice, MiddlewareConsumer, ModuleMetadata } from '@nestjs/common';
-import { ForgeController, ForgeModule, ForgeService } from '../architecture';
+import { INestApplication, INestApplicationContext, INestMicroservice, MiddlewareConsumer, ModuleMetadata, NestApplicationOptions } from '@nestjs/common';
+import { ForgeBaseComponent, ForgeController, ForgeModule, ForgeService } from '../architecture';
+import { NestApplicationContextOptions } from '@nestjs/common/interfaces/nest-application-context-options.interface';
+import { NestMicroserviceOptions } from '@nestjs/common/interfaces/microservices/nest-microservice-options.interface';
+import { AbstractHttpAdapter } from '@nestjs/core';
 export declare abstract class ForgeExtension {
     /**
      * The metdata for this extension.
@@ -9,27 +12,53 @@ export declare abstract class ForgeExtension {
      * Constructs a new forge extension instance.
      */
     constructor(options?: ForgeExtensionMetadata);
+    /**
+     * Configures the HTTP adapter to use for the Nest application instance.
+     *
+     * @param current The current adapter instance, or `undefined` if not set (default will be used).
+     */
+    configureHttpAdapter(current?: AbstractHttpAdapter): ForgeHttpAdapterLike;
     /**
      * Configures a Nest application instance.
      */
     configureHttpApplication(application: INestApplication): any;
+    /**
+     * Configures the options object for a Nest application instance.
+     */
+    configureHttpApplicationOptions(options: NestApplicationOptions): NestApplicationOptions | Promise<NestApplicationOptions>;
     /**
      * Configures a Nest application context. This is for a standalone application that has no web server.
      */
     configureStandaloneApplication(context: INestApplicationContext): any;
+    /**
+     * Configures the options object for a standalone Nest application instance.
+     */
+    configureStandaloneApplicationOptions(options: NestApplicationContextOptions): NestApplicationContextOptions | Promise<NestApplicationContextOptions>;
     /**
      * Configures a Nest microservice context.
      */
     configureMicroserviceApplication(context: INestMicroservice): any;
+    /**
+     * Configures the options object for a Nest microservice instance.
+     */
+    configureMicroserviceApplicationOptions(options: NestMicroserviceOptions): NestMicroserviceOptions | Promise<NestMicroserviceOptions>;
     /**
      * Configures the root module of the application.
      */
     configureRootModule(consumer: MiddlewareConsumer): any;
+    /**
+     * Runs after all services in the application have booted.
+     */
+    afterBoot(app: INestApplicationContext): any;
     /**
      * Instruments the application context. If a value is returned, the instance is replaced with that value, and no further extensions are
      * queried.
      */
     instrument(instance: unknown): any;
+    /**
+     * Augments a `ForgeBaseComponent` instance.
+     */
+    augmentComponent(instance: ForgeBaseComponent, moduleRef: any): any;
     /**
      * Augments a `ForgeModule` instance.
      */
@@ -54,3 +83,4 @@ export interface ForgeExtensionMetadata extends ModuleMetadata {
     extensions?: ForgeExtensionResolvable[];
 }
 export type ForgeExtensionResolvable = ForgeExtension | (new () => ForgeExtension) | null | undefined | false;
+export type ForgeHttpAdapterLike = AbstractHttpAdapter | null | undefined | Promise<AbstractHttpAdapter | null | undefined>;

package/dist/extensions/extension.js

@@ -12,27 +12,61 @@ class ForgeExtension {
     constructor(options) {
         this._metadata = options || {};
     }
+    /**
+     * Configures the HTTP adapter to use for the Nest application instance.
+     *
+     * @param current The current adapter instance, or `undefined` if not set (default will be used).
+     */
+    configureHttpAdapter(current) {
+        return;
+    }
     /**
      * Configures a Nest application instance.
      */
     configureHttpApplication(application) { }
+    /**
+     * Configures the options object for a Nest application instance.
+     */
+    configureHttpApplicationOptions(options) {
+        return options;
+    }
     /**
      * Configures a Nest application context. This is for a standalone application that has no web server.
      */
     configureStandaloneApplication(context) { }
+    /**
+     * Configures the options object for a standalone Nest application instance.
+     */
+    configureStandaloneApplicationOptions(options) {
+        return options;
+    }
     /**
      * Configures a Nest microservice context.
      */
     configureMicroserviceApplication(context) { }
+    /**
+     * Configures the options object for a Nest microservice instance.
+     */
+    configureMicroserviceApplicationOptions(options) {
+        return options;
+    }
     /**
      * Configures the root module of the application.
      */
     configureRootModule(consumer) { }
+    /**
+     * Runs after all services in the application have booted.
+     */
+    afterBoot(app) { }
     /**
      * Instruments the application context. If a value is returned, the instance is replaced with that value, and no further extensions are
      * queried.
      */
     instrument(instance) { }
+    /**
+     * Augments a `ForgeBaseComponent` instance.
+     */
+    augmentComponent(instance, moduleRef) { }
     /**
      * Augments a `ForgeModule` instance.
      */

package/dist/forge.factory.d.ts

@@ -1,29 +1,34 @@
-import { DynamicModule, ForwardReference, MiddlewareConsumer, Type } from '@nestjs/common';
+import { DynamicModule, ForwardReference, INestApplication, INestApplicationContext, MiddlewareConsumer, Type } from '@nestjs/common';
 import { ForgeApplicationContextOptions, ForgeApplicationOptions, ForgeMicroserviceOptions } from './forge-options.interface';
 import { ForgeExtension, ForgeExtensionResolvable } from './extensions';
-import { ModuleRef } from '@nestjs/core';
+import { AbstractHttpAdapter, ModuleRef } from '@nestjs/core';
 import { FORGE_ROOT_MODULE } from './constants';
 import { ForgeBaseComponent, ForgeController, ForgeModule, ForgeService } from './architecture';
 declare class Forge {
     private _augmented;
-    create(appModule: IEntryNestModule, options?: ForgeApplicationOptions): Promise<import("@nestjs/common").INestApplication<any>>;
-    createApplicationContext(appModule: IEntryNestModule, options: ForgeApplicationContextOptions): Promise<import("@nestjs/common").INestApplicationContext>;
+    create<T extends INestApplication = INestApplication>(appModule: IEntryNestModule, options?: ForgeApplicationOptions): Promise<T>;
+    create<T extends INestApplication = INestApplication>(appModule: IEntryNestModule, httpAdapter: AbstractHttpAdapter, options?: ForgeApplicationOptions): Promise<T>;
+    createApplicationContext(appModule: IEntryNestModule, options: ForgeApplicationContextOptions): Promise<INestApplicationContext>;
     createMicroservice<T extends object>(appModule: IEntryNestModule, options: ForgeMicroserviceOptions & T): Promise<import("@nestjs/common").INestMicroservice>;
     protected discoverExtensions(resolvables: ForgeExtensionResolvable | ForgeExtensionResolvable[]): ForgeExtension[];
-    protected resolveExtension(resolvable: ForgeExtensionResolvable): ForgeExtension;
+    protected resolveExtension(resolvable: ForgeExtensionResolvable): ForgeExtension | null;
     protected createRootModule(appModule: IEntryNestModule, extensions: ForgeExtension[]): {
         new (moduleRef: ModuleRef): {
             readonly moduleRef: ModuleRef;
-            configure(consumer: MiddlewareConsumer): void;
+            configure(consumer: MiddlewareConsumer): Promise<void>;
             readonly [FORGE_ROOT_MODULE]: true;
         };
     };
     protected createInstrument(extensions: ForgeExtension[], originalInstrument?: Instrument): InstrumentResponse;
-    protected augmentComponents(instances: ForgeBaseComponent[], extensions: ForgeExtension[]): void;
-    protected augmentModule(instance: ForgeModule, extensions: ForgeExtension[]): void;
-    protected augmentController(instance: ForgeController, extensions: ForgeExtension[]): void;
-    protected augmentService(instance: ForgeService, extensions: ForgeExtension[]): void;
+    protected augmentComponents(instances: ForgeBaseComponent[], extensions: ForgeExtension[]): Promise<void>;
+    protected augmentComponent(instance: ForgeBaseComponent, extensions: ForgeExtension[]): Promise<void>;
+    protected augmentModule(instance: ForgeModule, extensions: ForgeExtension[]): Promise<void>;
+    protected augmentController(instance: ForgeController, extensions: ForgeExtension[]): Promise<void>;
+    protected augmentService(instance: ForgeService, extensions: ForgeExtension[]): Promise<void>;
     protected _isRootModule(instance: unknown): instance is IForgeRootModule;
+    protected _isHttpAdapter(instance: unknown): instance is AbstractHttpAdapter;
+    protected _augmentBootHooks(createOptions: object, extensions: ForgeExtension[]): void;
+    protected _augmentNestApplication(): void;
 }
 type IEntryNestModule = Type<any> | DynamicModule | ForwardReference | Promise<IEntryNestModule>;
 type Instrument = {

package/dist/forge.factory.js

@@ -8,19 +8,39 @@ const constants_1 = require("./constants");
 const architecture_1 = require("./architecture");
 class Forge {
     _augmented = new Set();
-    async create(appModule, options) {
+    async create(appModule, optionsOrHttpAdapter, optionsFallback) {
+        let adapter = this._isHttpAdapter(optionsOrHttpAdapter) ? optionsOrHttpAdapter : undefined;
+        const options = (typeof optionsFallback === 'object' ? optionsFallback : adapter ? {} : optionsOrHttpAdapter) ??
+            {};
         const extensions = this.discoverExtensions(options?.extensions ?? []);
         const root = this.createRootModule(appModule, extensions);
         const instrument = this.createInstrument(extensions, options.instrument);
-        const app = await core_1.NestFactory.create(root, {
+        let createOptions = {
             ...options,
             instrument: {
                 instanceDecorator: instrument.instanceDecorator,
             },
-        });
-        this.augmentComponents(instrument.instances, extensions);
+        };
         for (const extension of extensions) {
-            extension.configureHttpApplication(app);
+            const newOptions = await extension.configureHttpApplicationOptions(createOptions);
+            const newAdapter = await extension.configureHttpAdapter(adapter);
+            if (typeof newOptions === 'object' && newOptions !== null) {
+                createOptions = newOptions;
+            }
+            if (typeof newAdapter === 'object' && newAdapter !== null) {
+                adapter = newAdapter;
+            }
+        }
+        const createArgs = [root, createOptions];
+        if (adapter) {
+            createArgs.splice(1, 0, adapter);
+        }
+        this._augmentBootHooks(createOptions, extensions);
+        this._augmentNestApplication();
+        const app = await core_1.NestFactory.create.apply(core_1.NestFactory, createArgs);
+        await this.augmentComponents(instrument.instances, extensions);
+        for (const extension of extensions) {
+            await extension.configureHttpApplication(app);
         }
         return app;
     }
@@ -28,31 +48,52 @@ class Forge {
         const extensions = this.discoverExtensions(options?.extensions ?? []);
         const root = this.createRootModule(appModule, extensions);
         const instrument = this.createInstrument(extensions, options.instrument);
-        const app = await core_1.NestFactory.createApplicationContext(root, {
+        let createOptions = {
             ...options,
             instrument: {
                 instanceDecorator: instrument.instanceDecorator,
             },
-        });
-        this.augmentComponents(instrument.instances, extensions);
+        };
         for (const extension of extensions) {
-            extension.configureStandaloneApplication(app);
+            const newOptions = await extension.configureStandaloneApplicationOptions(createOptions);
+            if (typeof newOptions === 'object' && newOptions !== null) {
+                createOptions = newOptions;
+            }
+        }
+        createOptions[constants_1.FORGE_PATCH_ENABLE_INIT] = false;
+        this._augmentBootHooks(createOptions, extensions);
+        this._augmentNestApplication();
+        const app = await core_1.NestFactory.createApplicationContext(root, createOptions);
+        await this.augmentComponents(instrument.instances, extensions);
+        for (const extension of extensions) {
+            await extension.configureStandaloneApplication(app);
         }
+        createOptions[constants_1.FORGE_PATCH_ENABLE_INIT] = true;
+        await app.init();
         return app;
     }
     async createMicroservice(appModule, options) {
         const extensions = this.discoverExtensions(options?.extensions ?? []);
         const root = this.createRootModule(appModule, extensions);
         const instrument = this.createInstrument(extensions, options.instrument);
-        const app = await core_1.NestFactory.createMicroservice(root, {
+        let createOptions = {
             ...options,
             instrument: {
                 instanceDecorator: instrument.instanceDecorator,
             },
-        });
-        this.augmentComponents(instrument.instances, extensions);
+        };
+        for (const extension of extensions) {
+            const newOptions = await extension.configureMicroserviceApplicationOptions(createOptions);
+            if (typeof newOptions === 'object' && newOptions !== null) {
+                createOptions = newOptions;
+            }
+        }
+        this._augmentBootHooks(createOptions, extensions);
+        this._augmentNestApplication();
+        const app = await core_1.NestFactory.createMicroservice(root, createOptions);
+        await this.augmentComponents(instrument.instances, extensions);
         for (const extension of extensions) {
-            extension.configureMicroserviceApplication(app);
+            await extension.configureMicroserviceApplication(app);
         }
         return app;
     }
@@ -108,9 +149,9 @@ class Forge {
             constructor(moduleRef) {
                 this.moduleRef = moduleRef;
             }
-            configure(consumer) {
+            async configure(consumer) {
                 for (const extension of extensions) {
-                    extension.configureRootModule(consumer);
+                    await extension.configureRootModule(consumer);
                 }
             }
         };
@@ -161,40 +202,80 @@ class Forge {
             },
         };
     }
-    augmentComponents(instances, extensions) {
+    async augmentComponents(instances, extensions) {
         for (const instance of instances) {
             if (!this._augmented.has(instance)) {
+                await this.augmentComponent(instance, extensions);
                 if (instance instanceof architecture_1.ForgeModule) {
-                    this.augmentModule(instance, extensions);
+                    await this.augmentModule(instance, extensions);
                 }
                 else if (instance instanceof architecture_1.ForgeController) {
-                    this.augmentController(instance, extensions);
+                    await this.augmentController(instance, extensions);
                 }
                 else if (instance instanceof architecture_1.ForgeService) {
-                    this.augmentService(instance, extensions);
+                    await this.augmentService(instance, extensions);
                 }
                 this._augmented.add(instance);
             }
         }
     }
-    augmentModule(instance, extensions) {
+    async augmentComponent(instance, extensions) {
         for (const extension of extensions) {
-            extension.augmentModule(instance, instance[constants_1.FORGE_FIELD_MODULE_REF]);
+            await extension.augmentComponent(instance, instance[constants_1.FORGE_FIELD_MODULE_REF]);
         }
     }
-    augmentController(instance, extensions) {
+    async augmentModule(instance, extensions) {
         for (const extension of extensions) {
-            extension.augmentController(instance, instance[constants_1.FORGE_FIELD_MODULE_REF]);
+            await extension.augmentModule(instance, instance[constants_1.FORGE_FIELD_MODULE_REF]);
         }
     }
-    augmentService(instance, extensions) {
+    async augmentController(instance, extensions) {
         for (const extension of extensions) {
-            extension.augmentService(instance, instance[constants_1.FORGE_FIELD_MODULE_REF]);
+            await extension.augmentController(instance, instance[constants_1.FORGE_FIELD_MODULE_REF]);
+        }
+    }
+    async augmentService(instance, extensions) {
+        for (const extension of extensions) {
+            await extension.augmentService(instance, instance[constants_1.FORGE_FIELD_MODULE_REF]);
         }
     }
     _isRootModule(instance) {
         return typeof instance === 'object' && instance !== null && instance[constants_1.FORGE_ROOT_MODULE] === true;
     }
+    _isHttpAdapter(instance) {
+        return typeof instance === 'object' && instance !== null && typeof instance['use'] === 'function';
+    }
+    _augmentBootHooks(createOptions, extensions) {
+        createOptions[constants_1.FORGE_PATCH_BOOT_CALLBACK] = async (app) => {
+            try {
+                await Promise.all(extensions.map((e) => e.afterBoot(app)));
+            }
+            catch (error) {
+                console.error(error);
+            }
+        };
+    }
+    _augmentNestApplication() {
+        const application = core_1.NestApplicationContext;
+        const originalBootstrapHook = application.prototype.callBootstrapHook;
+        const originalInit = application.prototype.init;
+        if (application.prototype[constants_1.FORGE_PATCHED]) {
+            return;
+        }
+        application.prototype[constants_1.FORGE_PATCHED] = true;
+        application.prototype.callBootstrapHook = async function () {
+            await originalBootstrapHook.call(this);
+            if (this.appOptions[constants_1.FORGE_PATCH_BOOT_CALLBACK]) {
+                await this.appOptions[constants_1.FORGE_PATCH_BOOT_CALLBACK](this);
+            }
+        };
+        application.prototype.init = async function () {
+            if (this.appOptions[constants_1.FORGE_PATCH_ENABLE_INIT] === false) {
+                return this;
+            }
+            return originalInit.call(this);
+        };
+    }
 }
 const forge = new Forge();
 exports.Forge = forge;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@nest-forge/core",
 	"description": "",
-	"version": "0.0.2",
+	"version": "0.0.3",
 	"scripts": {
 		"build": "rimraf dist && tsc -p tsconfig.json",
 		"watch": "rimraf dist && tsc -w -p tsconfig.json",
@@ -31,14 +31,12 @@
 	"devDependencies": {
 		"@eslint/eslintrc": "^3.3.3",
 		"@eslint/js": "^9.39.2",
-		"@types/node": "~25.0.0",
+		"@types/node": "~24.0.0",
 		"eslint": "^9.18.0",
 		"eslint-config-prettier": "^10.1.8",
-		"eslint-plugin-import": "^2.32.0",
 		"eslint-plugin-prettier": "^5.5.4",
 		"globals": "^16.0.0",
 		"prettier": "3.7.4",
-		"reflect-metadata": "^0.2.2",
 		"rimraf": "^6.1.2",
 		"typescript": "^5.9.0",
 		"typescript-eslint": "^8.51.0"

package/tsconfig.json

@@ -17,7 +17,8 @@
 		"outDir": "./dist",
 		"forceConsistentCasingInFileNames": true,
 		"strictPropertyInitialization": false,
-		"stripInternal": true
+		"stripInternal": true,
+		"strict": true
 	},
 	"include": [
 		"src/**/*"

package/.prettierignore

@@ -1,3 +0,0 @@
-pnpm-lock.yaml
-package-lock.json
-yarn.lock

package/.prettierrc

@@ -1,7 +0,0 @@
-{
-	"parser": "typescript",
-	"useTabs": true,
-	"singleQuote": true,
-	"trailingComma": "es5",
-	"printWidth": 140
-}

package/eslint.config.mjs

@@ -1,31 +0,0 @@
-import eslint from '@eslint/js';
-import { defineConfig } from 'eslint/config';
-import eslintPluginPrettierRecommended from 'eslint-plugin-prettier/recommended';
-import tseslint from 'typescript-eslint';
-import globals from 'globals';
-
-export default defineConfig(
-	{
-		ignores: ['node_modules', '**/node_modules/**', '**/*.js', '**/*.d.ts']
-	},
-	eslint.configs.recommended,
-	...tseslint.configs.recommendedTypeChecked,
-	eslintPluginPrettierRecommended,
-	{
-		languageOptions: {
-			globals: {
-				...globals.node,
-				...globals.jest
-			},
-			ecmaVersion: 2024,
-			sourceType: 'module',
-			parserOptions: {
-				projectService: true,
-				tsconfigRootDir: import.meta.dirname
-			}
-		}
-	},
-	{
-		rules: {}
-	}
-);