@nest-forge/core 0.0.1

package/.prettierignore

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

package/.prettierrc

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

package/dist/extensions/extension.d.ts

@@ -0,0 +1,39 @@
+import { INestApplication, INestApplicationContext, MiddlewareConsumer, ModuleMetadata } from '@nestjs/common';
+export declare abstract class ForgeExtension {
+    /**
+     * The metdata for this extension.
+     */
+    private readonly _metadata;
+    /**
+     * Constructs a new forge extension instance.
+     */
+    constructor(options?: ForgeExtensionMetadata);
+    /**
+     * Configures a Nest application instance.
+     */
+    configureHttpApplication(application: INestApplication): any;
+    /**
+     * Configures a Nest application context. This is
+     */
+    configureStandaloneApplication(context: INestApplicationContext): any;
+    /**
+     * Configures the root module of the application.
+     */
+    configureRootModule(consumer: MiddlewareConsumer): 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;
+    /**
+     * Returns the metadata for this extension.
+     */
+    getMetadata(): ForgeExtensionMetadata;
+}
+export interface ForgeExtensionMetadata extends ModuleMetadata {
+    /**
+     * An optional array of nested extensions to import.
+     */
+    extensions?: ForgeExtensionResolvable[];
+}
+export type ForgeExtensionResolvable = ForgeExtension | (new () => ForgeExtension) | null | undefined | false;

package/dist/extensions/extension.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForgeExtension = void 0;
+class ForgeExtension {
+    /**
+     * The metdata for this extension.
+     */
+    _metadata;
+    /**
+     * Constructs a new forge extension instance.
+     */
+    constructor(options) {
+        this._metadata = options || {};
+    }
+    /**
+     * Configures a Nest application instance.
+     */
+    configureHttpApplication(application) { }
+    /**
+     * Configures a Nest application context. This is
+     */
+    configureStandaloneApplication(context) { }
+    /**
+     * Configures the root module of the application.
+     */
+    configureRootModule(consumer) { }
+    /**
+     * Instruments the application context. If a value is returned, the instance is replaced with that value, and no further extensions are
+     * queried.
+     */
+    instrument(instance) { }
+    /**
+     * Returns the metadata for this extension.
+     */
+    getMetadata() {
+        return this._metadata;
+    }
+}
+exports.ForgeExtension = ForgeExtension;

package/dist/extensions/index.d.ts

@@ -0,0 +1 @@
+export * from './extension';

package/dist/extensions/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./extension"), exports);

package/dist/forge-options.interface.d.ts

@@ -0,0 +1,9 @@
+import { NestApplicationOptions } from '@nestjs/common';
+import { ForgeExtensionResolvable } from './extensions';
+import { NestApplicationContextOptions } from '@nestjs/common/interfaces/nest-application-context-options.interface';
+export interface ForgeApplicationOptions extends NestApplicationOptions {
+    extensions?: ForgeExtensionResolvable | ForgeExtensionResolvable[];
+}
+export interface ForgeApplicationContextOptions extends NestApplicationContextOptions {
+    extensions?: ForgeExtensionResolvable | ForgeExtensionResolvable[];
+}

package/dist/forge-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/forge.factory.d.ts

@@ -0,0 +1,21 @@
+import { DynamicModule, ForwardReference, MiddlewareConsumer, Type } from '@nestjs/common';
+import { ForgeApplicationContextOptions, ForgeApplicationOptions } from './forge-options.interface';
+import { ForgeExtension, ForgeExtensionResolvable } from './extensions';
+declare class Forge {
+    create(appModule: IEntryNestModule, options?: ForgeApplicationOptions): Promise<import("@nestjs/common").INestApplication<any>>;
+    createApplicationContext(appModule: IEntryNestModule, options: ForgeApplicationContextOptions): Promise<import("@nestjs/common").INestApplicationContext>;
+    protected discoverExtensions(resolvables: ForgeExtensionResolvable | ForgeExtensionResolvable[]): ForgeExtension[];
+    protected resolveExtension(resolvable: ForgeExtensionResolvable): ForgeExtension;
+    protected createRootModule(appModule: IEntryNestModule, extensions: ForgeExtension[]): {
+        new (): {
+            configure(consumer: MiddlewareConsumer): void;
+        };
+    };
+    protected createInstrument(extensions: ForgeExtension[], originalInstrument?: Instrument): Instrument;
+}
+type IEntryNestModule = Type<any> | DynamicModule | ForwardReference | Promise<IEntryNestModule>;
+type Instrument = {
+    instanceDecorator: (instance: unknown) => unknown;
+};
+declare const forge: Forge;
+export { forge as Forge };

package/dist/forge.factory.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Forge = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+class Forge {
+    async create(appModule, options) {
+        const extensions = this.discoverExtensions(options?.extensions ?? []);
+        const root = this.createRootModule(appModule, extensions);
+        const app = await core_1.NestFactory.create(root, {
+            ...options,
+            instrument: this.createInstrument(extensions, options.instrument),
+        });
+        for (const extension of extensions) {
+            extension.configureHttpApplication(app);
+        }
+        return app;
+    }
+    async createApplicationContext(appModule, options) {
+        const extensions = this.discoverExtensions(options?.extensions ?? []);
+        const root = this.createRootModule(appModule, extensions);
+        const app = await core_1.NestFactory.createApplicationContext(root, {
+            ...options,
+            instrument: this.createInstrument(extensions, options.instrument),
+        });
+        for (const extension of extensions) {
+            extension.configureStandaloneApplication(app);
+        }
+        return app;
+    }
+    discoverExtensions(resolvables) {
+        const extensions = new Map();
+        if (!Array.isArray(resolvables)) {
+            resolvables = [resolvables];
+        }
+        for (const resolvable of resolvables) {
+            const extension = this.resolveExtension(resolvable);
+            if (extension !== null) {
+                const metadata = extension.getMetadata();
+                for (const nestedExtension of this.discoverExtensions(metadata.extensions)) {
+                    extensions.delete(nestedExtension.constructor);
+                    extensions.set(nestedExtension.constructor, nestedExtension);
+                }
+                extensions.delete(extension.constructor);
+                extensions.set(extension.constructor, extension);
+            }
+        }
+        return Array.from(extensions.values());
+    }
+    resolveExtension(resolvable) {
+        if (resolvable === false || resolvable === null || resolvable === undefined) {
+            return null;
+        }
+        if (typeof resolvable === 'object') {
+            return resolvable;
+        }
+        if (typeof resolvable === 'function') {
+            return new resolvable();
+        }
+        throw new Error(`Unsupported extension resolvable "${String(resolvable)}"`);
+    }
+    createRootModule(appModule, extensions) {
+        const meta = {
+            imports: [appModule],
+            controllers: [],
+            providers: [],
+            exports: [],
+        };
+        for (const extension of extensions) {
+            const extensionMeta = extension.getMetadata();
+            meta.imports.push(...(extensionMeta.imports ?? []));
+            meta.controllers.push(...(extensionMeta.controllers ?? []));
+            meta.providers.push(...(extensionMeta.providers ?? []));
+            meta.exports.push(...(extensionMeta.exports ?? []));
+        }
+        let ForgeRootModule = class ForgeRootModule {
+            configure(consumer) {
+                for (const extension of extensions) {
+                    extension.configureRootModule(consumer);
+                }
+            }
+        };
+        ForgeRootModule = tslib_1.__decorate([
+            (0, common_1.Module)(meta)
+        ], ForgeRootModule);
+        return ForgeRootModule;
+    }
+    createInstrument(extensions, originalInstrument) {
+        const hasOriginalInstrument = originalInstrument && originalInstrument.instanceDecorator;
+        return {
+            instanceDecorator(instance) {
+                for (const extension of extensions) {
+                    const response = extension.instrument(instance);
+                    if (response !== undefined) {
+                        return response;
+                    }
+                }
+                if (hasOriginalInstrument) {
+                    return originalInstrument.instanceDecorator(instance);
+                }
+                return instance;
+            },
+        };
+    }
+}
+const forge = new Forge();
+exports.Forge = forge;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './forge.factory';
+export * from './forge-options.interface';
+export * from './extensions';

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./forge.factory"), exports);
+tslib_1.__exportStar(require("./forge-options.interface"), exports);
+tslib_1.__exportStar(require("./extensions"), exports);

package/eslint.config.mjs

@@ -0,0 +1,31 @@
+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: {}
+	}
+);

package/package.json

@@ -0,0 +1,55 @@
+{
+	"name": "@nest-forge/core",
+	"description": "",
+	"version": "0.0.1",
+	"scripts": {
+		"build": "rimraf dist && tsc -p tsconfig.json",
+		"watch": "rimraf dist && tsc -w -p tsconfig.json",
+		"format": "prettier --write \"{src,apps,libs,test}/**/*.ts\"",
+		"lint": "eslint --ignore-pattern .gitignore \"{src,apps,libs,test}/**/*.ts\""
+	},
+	"directories": {
+		"lib": "src"
+	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"keywords": [],
+	"license": "UNLICENSED",
+	"homepage": "https://github.com/nest-forge",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/nest-forge/core"
+	},
+	"bugs": {
+		"url": "https://github.com/nest-forge/core/issues"
+	},
+	"author": "Bailey Herbert <hello@bailey.sh>",
+	"contributors": [],
+	"dependencies": {
+		"tslib": "^2.8.1"
+	},
+	"devDependencies": {
+		"@eslint/eslintrc": "^3.3.3",
+		"@eslint/js": "^9.39.2",
+		"@types/node": "~25.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"
+	},
+	"peerDependencies": {
+		"@nestjs/common": "^10.2.0 || ^11.0.0",
+		"@nestjs/core": "^10.2.0 || ^11.0.0",
+		"reflect-metadata": "^0.2.1"
+	},
+	"engines": {
+		"node": ">=24",
+		"npm": ">=10.0.0"
+	}
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+	"compilerOptions": {
+		"module": "commonjs",
+		"declaration": true,
+		"noImplicitAny": false,
+		"skipLibCheck": true,
+		"noUnusedLocals": false,
+		"importHelpers": true,
+		"removeComments": false,
+		"noLib": false,
+		"emitDecoratorMetadata": true,
+		"experimentalDecorators": true,
+		"useUnknownInCatchVariables": false,
+		"target": "ES2024",
+		"sourceMap": false,
+		"allowJs": false,
+		"outDir": "./dist",
+		"baseUrl": ".",
+		"forceConsistentCasingInFileNames": true,
+		"strictPropertyInitialization": false,
+		"stripInternal": true
+	},
+	"include": [
+		"src/**/*"
+	],
+	"exclude": [
+		"node_modules",
+		"dist"
+	]
+}