@nest-forge/core 0.0.4 → 0.0.5

package/dist/architecture/component.d.ts

@@ -0,0 +1,7 @@
+export declare abstract class ForgeBaseComponent {
+    protected onModuleInit(): any;
+    protected onApplicationBootstrap(): any;
+    protected onModuleDestroy(signal: string): any;
+    protected beforeApplicationShutdown(signal: string): any;
+    protected onApplicationShutdown(signal: string): any;
+}

package/dist/architecture/component.js

@@ -0,0 +1,24 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForgeBaseComponent = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const constants_1 = require("../constants");
+const core_1 = require("@nestjs/core");
+class ForgeBaseComponent {
+    /**
+     * @internal
+     */
+    [_a = constants_1.FORGE_FIELD_MODULE_REF];
+    onModuleInit() { }
+    onApplicationBootstrap() { }
+    onModuleDestroy(signal) { }
+    beforeApplicationShutdown(signal) { }
+    onApplicationShutdown(signal) { }
+}
+exports.ForgeBaseComponent = ForgeBaseComponent;
+tslib_1.__decorate([
+    (0, common_1.Inject)(core_1.ModuleRef),
+    tslib_1.__metadata("design:type", core_1.ModuleRef)
+], ForgeBaseComponent.prototype, _a, void 0);

package/dist/architecture/controller.d.ts

@@ -0,0 +1,3 @@
+import { ForgeBaseComponent } from './component';
+export declare abstract class ForgeController extends ForgeBaseComponent {
+}

package/dist/architecture/controller.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForgeController = void 0;
+const component_1 = require("./component");
+class ForgeController extends component_1.ForgeBaseComponent {
+}
+exports.ForgeController = ForgeController;

package/dist/architecture/index.d.ts

@@ -0,0 +1,4 @@
+export * from './component';
+export * from './module';
+export * from './controller';
+export * from './service';

package/dist/architecture/index.js

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

package/dist/architecture/module.d.ts

@@ -0,0 +1,5 @@
+import { MiddlewareConsumer } from '@nestjs/common';
+import { ForgeBaseComponent } from './component';
+export declare abstract class ForgeModule extends ForgeBaseComponent {
+    configure(consumer: MiddlewareConsumer): any;
+}

package/dist/architecture/module.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForgeModule = void 0;
+const component_1 = require("./component");
+class ForgeModule extends component_1.ForgeBaseComponent {
+    configure(consumer) { }
+}
+exports.ForgeModule = ForgeModule;

package/dist/architecture/service.d.ts

@@ -0,0 +1,3 @@
+import { ForgeBaseComponent } from './component';
+export declare abstract class ForgeService extends ForgeBaseComponent {
+}

package/dist/architecture/service.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForgeService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const component_1 = require("./component");
+let ForgeService = class ForgeService extends component_1.ForgeBaseComponent {
+};
+exports.ForgeService = ForgeService;
+exports.ForgeService = ForgeService = tslib_1.__decorate([
+    (0, common_1.Injectable)()
+], ForgeService);

package/dist/constants-public.d.ts

@@ -0,0 +1,2 @@
+export declare const FORGE_ROOT_MODULE: unique symbol;
+export declare const FORGE_APP_OPTIONS: unique symbol;

package/dist/constants-public.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORGE_APP_OPTIONS = exports.FORGE_ROOT_MODULE = void 0;
+exports.FORGE_ROOT_MODULE = Symbol('FORGE_ROOT_MODULE');
+exports.FORGE_APP_OPTIONS = Symbol('FORGE_APP_OPTIONS');

package/dist/constants.d.ts

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORGE_PATCH_ENABLE_INIT = exports.FORGE_PATCH_BOOT_CALLBACK = exports.FORGE_PATCHED = exports.FORGE_TOKEN_ROOT_MODULE = exports.FORGE_FIELD_MODULE_REF = void 0;
+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

@@ -0,0 +1,92 @@
+import { 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, NestApplication } from '@nestjs/core';
+export declare abstract class ForgeExtension {
+    /**
+     * 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: NestApplication): 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.
+     */
+    augmentModule(instance: ForgeModule, moduleRef: any): any;
+    /**
+     * Augments a `ForgeController` instance.
+     */
+    augmentController(instance: ForgeController, moduleRef: any): any;
+    /**
+     * Augments a `ForgeService` instance.
+     */
+    augmentService(instance: ForgeService, moduleRef: any): any;
+    /**
+     * Returns an array of imports to add onto the root module.
+     */
+    getRootImports(): ModuleImport[];
+    /**
+     * Returns an array of providers to add onto the root module.
+     */
+    getRootProviders(): ModuleProvider[];
+    /**
+     * Returns an array of controllers to add onto the root module.
+     */
+    getRootControllers(): ModuleController[];
+    /**
+     * Returns an array of exports to add onto the root module.
+     */
+    getRootExports(): ModuleExport[];
+    /**
+     * Returns an array of nested extensions that will be imported along with this one.
+     */
+    getNestedExtensions(): ForgeExtensionResolvable[];
+}
+export type ModuleImport = NonNullable<ModuleMetadata['imports']>[number];
+export type ModuleProvider = NonNullable<ModuleMetadata['providers']>[number];
+export type ModuleController = NonNullable<ModuleMetadata['controllers']>[number];
+export type ModuleExport = NonNullable<ModuleMetadata['exports']>[number];
+export type ForgeExtensionResolvable = ForgeExtension | (new () => ForgeExtension) | null | undefined | false;
+export type ForgeHttpAdapterLike = AbstractHttpAdapter | null | undefined | Promise<AbstractHttpAdapter | null | undefined>;

package/dist/extensions/extension.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForgeExtension = void 0;
+class ForgeExtension {
+    /**
+     * 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.
+     */
+    augmentModule(instance, moduleRef) { }
+    /**
+     * Augments a `ForgeController` instance.
+     */
+    augmentController(instance, moduleRef) { }
+    /**
+     * Augments a `ForgeService` instance.
+     */
+    augmentService(instance, moduleRef) { }
+    /**
+     * Returns an array of imports to add onto the root module.
+     */
+    getRootImports() {
+        return [];
+    }
+    /**
+     * Returns an array of providers to add onto the root module.
+     */
+    getRootProviders() {
+        return [];
+    }
+    /**
+     * Returns an array of controllers to add onto the root module.
+     */
+    getRootControllers() {
+        return [];
+    }
+    /**
+     * Returns an array of exports to add onto the root module.
+     */
+    getRootExports() {
+        return [];
+    }
+    /**
+     * Returns an array of nested extensions that will be imported along with this one.
+     */
+    getNestedExtensions() {
+        return [];
+    }
+}
+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,13 @@
+import { NestApplicationOptions } from '@nestjs/common';
+import { ForgeExtensionResolvable } from './extensions';
+import { NestApplicationContextOptions } from '@nestjs/common/interfaces/nest-application-context-options.interface';
+import { NestMicroserviceOptions } from '@nestjs/common/interfaces/microservices/nest-microservice-options.interface';
+export interface ForgeApplicationOptions extends NestApplicationOptions {
+    extensions?: ForgeExtensionResolvable | ForgeExtensionResolvable[];
+}
+export interface ForgeApplicationContextOptions extends NestApplicationContextOptions {
+    extensions?: ForgeExtensionResolvable | ForgeExtensionResolvable[];
+}
+export interface ForgeMicroserviceOptions extends NestMicroserviceOptions {
+    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,49 @@
+import { DynamicModule, ForwardReference, INestApplication, INestApplicationContext, MiddlewareConsumer, ModuleMetadata, Type } from '@nestjs/common';
+import { ForgeApplicationContextOptions, ForgeApplicationOptions, ForgeMicroserviceOptions } from './forge-options.interface';
+import { ForgeExtension, ForgeExtensionResolvable } from './extensions';
+import { AbstractHttpAdapter, ModuleRef, NestApplication } from '@nestjs/core';
+import { ForgeBaseComponent, ForgeController, ForgeModule, ForgeService } from './architecture';
+import { FORGE_ROOT_MODULE } from './constants-public';
+declare class Forge {
+    private _augmented;
+    create<T extends INestApplication = NestApplication>(appModule: IEntryNestModule, options?: ForgeApplicationOptions): Promise<T>;
+    create<T extends INestApplication = NestApplication>(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 | null;
+    protected createRootModule(appModule: IEntryNestModule, extensions: ForgeExtension[], options: any): Promise<{
+        new (moduleRef: ModuleRef): {
+            readonly moduleRef: ModuleRef;
+            configure(consumer: MiddlewareConsumer): Promise<void>;
+            readonly [FORGE_ROOT_MODULE]: true;
+        };
+    }>;
+    protected _getExtensionMetadata(extension: ForgeExtension): Promise<ExtensionMetadata>;
+    protected createInstrument(extensions: ForgeExtension[], originalInstrument?: Instrument): InstrumentResponse;
+    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 = {
+    instanceDecorator: (instance: unknown) => unknown;
+};
+type NonNullableFields<T> = {
+    [P in keyof T]-?: NonNullable<T[P]>;
+};
+interface InstrumentResponse {
+    instances: ForgeBaseComponent[];
+    instanceDecorator: (instance: unknown) => any;
+}
+interface ExtensionMetadata extends NonNullableFields<ModuleMetadata> {
+    extensions: ForgeExtensionResolvable[];
+}
+declare const forge: Forge;
+export { forge as Forge };

package/dist/forge.factory.js

@@ -0,0 +1,296 @@
+"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");
+const constants_1 = require("./constants");
+const architecture_1 = require("./architecture");
+const constants_public_1 = require("./constants-public");
+class Forge {
+    _augmented = new Set();
+    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 = await this.createRootModule(appModule, extensions, options);
+        const instrument = this.createInstrument(extensions, options.instrument);
+        let createOptions = {
+            ...options,
+            instrument: {
+                instanceDecorator: instrument.instanceDecorator,
+            },
+        };
+        for (const extension of extensions) {
+            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;
+    }
+    async createApplicationContext(appModule, options) {
+        const extensions = this.discoverExtensions(options?.extensions ?? []);
+        const root = this.createRootModule(appModule, extensions, options);
+        const instrument = this.createInstrument(extensions, options.instrument);
+        let createOptions = {
+            ...options,
+            instrument: {
+                instanceDecorator: instrument.instanceDecorator,
+            },
+        };
+        for (const extension of extensions) {
+            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, options);
+        const instrument = this.createInstrument(extensions, options.instrument);
+        let createOptions = {
+            ...options,
+            instrument: {
+                instanceDecorator: instrument.instanceDecorator,
+            },
+        };
+        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) {
+            await extension.configureMicroserviceApplication(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) {
+                for (const nestedExtension of this.discoverExtensions(extension.getNestedExtensions())) {
+                    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)}"`);
+    }
+    async createRootModule(appModule, extensions, options) {
+        const meta = {
+            imports: [],
+            controllers: [],
+            providers: [],
+            exports: [],
+        };
+        for (const extension of extensions) {
+            const extensionMeta = await this._getExtensionMetadata(extension);
+            meta.imports.push(...extensionMeta.imports);
+            meta.controllers.push(...extensionMeta.controllers);
+            meta.providers.push(...extensionMeta.providers);
+            meta.exports.push(...extensionMeta.exports);
+        }
+        meta.imports.push(appModule);
+        let ForgeRootModule = class ForgeRootModule {
+            moduleRef;
+            [constants_public_1.FORGE_ROOT_MODULE] = true;
+            constructor(moduleRef) {
+                this.moduleRef = moduleRef;
+            }
+            async configure(consumer) {
+                for (const extension of extensions) {
+                    await extension.configureRootModule(consumer);
+                }
+            }
+        };
+        ForgeRootModule = tslib_1.__decorate([
+            (0, common_1.Module)(meta),
+            (0, common_1.Global)(),
+            tslib_1.__metadata("design:paramtypes", [core_1.ModuleRef])
+        ], ForgeRootModule);
+        let ForgeRootProviderModule = class ForgeRootProviderModule {
+        };
+        ForgeRootProviderModule = tslib_1.__decorate([
+            (0, common_1.Global)(),
+            (0, common_1.Module)({
+                providers: [
+                    {
+                        provide: constants_1.FORGE_TOKEN_ROOT_MODULE,
+                        useClass: ForgeRootModule,
+                    },
+                    {
+                        provide: constants_public_1.FORGE_APP_OPTIONS,
+                        useValue: options,
+                    },
+                ],
+                exports: [constants_1.FORGE_TOKEN_ROOT_MODULE, constants_public_1.FORGE_APP_OPTIONS],
+            })
+        ], ForgeRootProviderModule);
+        meta.imports.unshift(ForgeRootProviderModule);
+        return ForgeRootModule;
+    }
+    async _getExtensionMetadata(extension) {
+        const results = await Promise.all([
+            extension.getRootImports(),
+            extension.getRootProviders(),
+            extension.getRootExports(),
+            extension.getRootControllers(),
+            extension.getNestedExtensions(),
+        ]);
+        return {
+            imports: results[0],
+            providers: results[1],
+            exports: results[2],
+            controllers: results[3],
+            extensions: results[4],
+        };
+    }
+    createInstrument(extensions, originalInstrument) {
+        const hasOriginalInstrument = originalInstrument && originalInstrument.instanceDecorator;
+        const instances = new Array();
+        return {
+            instances,
+            instanceDecorator: (instance) => {
+                if (this._isRootModule(instance)) {
+                    // TODO
+                }
+                if (instance instanceof architecture_1.ForgeBaseComponent) {
+                    instances.push(instance);
+                }
+                for (const extension of extensions) {
+                    const response = extension.instrument(instance);
+                    if (response !== undefined) {
+                        return response;
+                    }
+                }
+                if (hasOriginalInstrument) {
+                    return originalInstrument.instanceDecorator(instance);
+                }
+                return instance;
+            },
+        };
+    }
+    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) {
+                    await this.augmentModule(instance, extensions);
+                }
+                else if (instance instanceof architecture_1.ForgeController) {
+                    await this.augmentController(instance, extensions);
+                }
+                else if (instance instanceof architecture_1.ForgeService) {
+                    await this.augmentService(instance, extensions);
+                }
+                this._augmented.add(instance);
+            }
+        }
+    }
+    async augmentComponent(instance, extensions) {
+        for (const extension of extensions) {
+            await extension.augmentComponent(instance, instance[constants_1.FORGE_FIELD_MODULE_REF]);
+        }
+    }
+    async augmentModule(instance, extensions) {
+        for (const extension of extensions) {
+            await extension.augmentModule(instance, instance[constants_1.FORGE_FIELD_MODULE_REF]);
+        }
+    }
+    async augmentController(instance, extensions) {
+        for (const extension of extensions) {
+            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_public_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) => {
+            await Promise.all(extensions.map((e) => e.afterBoot(app)));
+        };
+    }
+    _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/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './forge.factory';
+export * from './forge-options.interface';
+export * from './extensions';
+export * from './architecture';
+export * from './constants-public';

package/dist/index.js

@@ -0,0 +1,8 @@
+"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);
+tslib_1.__exportStar(require("./architecture"), exports);
+tslib_1.__exportStar(require("./constants-public"), exports);

package/package.json

@@ -1,22 +1,26 @@
 {
 	"name": "@nest-forge/core",
 	"description": "",
-	"version": "0.0.4",
+	"version": "0.0.5",
 	"scripts": {
 		"build": "rimraf dist && tsc -p tsconfig.json",
 		"watch": "rimraf dist && tsc -w -p tsconfig.json",
 		"format": "prettier --write \"{src,apps,libs,test}/**/*.ts\""
 	},
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
 	"directories": {
 		"lib": "src"
 	},
-	"main": "./dist/index.js",
-	"types": "./dist/index.d.ts",
+	"files": [
+		"dist",
+		"tsconfig.json"
+	],
 	"keywords": [],
 	"license": "UNLICENSED",
 	"repository": {
 		"type": "git",
-		"url": "https://github.com/baileyherbert/nest-forge"
+		"url": "git+https://github.com/baileyherbert/nest-forge.git"
 	},
 	"bugs": {
 		"url": "https://github.com/baileyherbert/nest-forge/issues"