@velajs/vela 1.0.0 → 1.2.0

package/dist/testing/testing.builder.js

@@ -1,148 +0,0 @@
-import { VelaApplication } from "../application.js";
-import { METADATA_KEYS } from "../constants.js";
-import { Container } from "../container/container.js";
-import { RouteManager } from "../http/route.manager.js";
-import { defineMetadata } from "../metadata.js";
-import { ModuleLoader } from "../module/module-loader.js";
-import { ComponentManager } from "../pipeline/component.manager.js";
-import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_MIDDLEWARE, APP_PIPE } from "../pipeline/tokens.js";
-import { MetadataRegistry } from "../registry/metadata.registry.js";
-import { TestingModule } from "./testing.module.js";
-export class OverrideBy {
-    builder;
-    token;
-    constructor(builder, token){
-        this.builder = builder;
-        this.token = token;
-    }
-    useValue(value) {
-        this.builder['addOverride']({
-            token: this.token,
-            provider: {
-                provide: this.token,
-                useValue: value
-            }
-        });
-        return this.builder;
-    }
-    useClass(cls) {
-        this.builder['addOverride']({
-            token: this.token,
-            provider: {
-                provide: this.token,
-                useClass: cls
-            }
-        });
-        return this.builder;
-    }
-    useFactory(options) {
-        this.builder['addOverride']({
-            token: this.token,
-            provider: {
-                provide: this.token,
-                useFactory: options.factory,
-                inject: options.inject
-            }
-        });
-        return this.builder;
-    }
-}
-export class TestingModuleBuilder {
-    metadata;
-    overrides = [];
-    constructor(metadata){
-        this.metadata = metadata;
-    }
-    overrideProvider(token) {
-        return new OverrideBy(this, token);
-    }
-    overrideGuard(guard) {
-        return new OverrideBy(this, guard);
-    }
-    overridePipe(pipe) {
-        return new OverrideBy(this, pipe);
-    }
-    overrideInterceptor(interceptor) {
-        return new OverrideBy(this, interceptor);
-    }
-    overrideFilter(filter) {
-        return new OverrideBy(this, filter);
-    }
-    addOverride(entry) {
-        // Replace existing override for same token if any
-        const idx = this.overrides.findIndex((o)=>o.token === entry.token);
-        if (idx !== -1) {
-            this.overrides[idx] = entry;
-        } else {
-            this.overrides.push(entry);
-        }
-    }
-    async compile() {
-        // Create a temporary module class with the provided metadata
-        let TestRootModule = class TestRootModule {
-        };
-        MetadataRegistry.setModuleOptions(TestRootModule, {
-            imports: this.metadata.imports,
-            providers: this.metadata.providers,
-            controllers: this.metadata.controllers,
-            exports: this.metadata.exports
-        });
-        defineMetadata(METADATA_KEYS.MODULE, true, TestRootModule);
-        // Bootstrap (mirrors VelaFactory.create)
-        const container = new Container();
-        container.register({
-            provide: Container,
-            useValue: container
-        });
-        // Register overrides BEFORE module loading so ModuleLoader skips originals
-        for (const override of this.overrides){
-            container.register(override.provider);
-        }
-        const routeManager = new RouteManager(container);
-        ComponentManager.init(container);
-        const loader = new ModuleLoader(container, routeManager);
-        loader.load(TestRootModule);
-        const appGuards = loader.getAppProviderTokens(APP_GUARD);
-        if (appGuards.length > 0) {
-            routeManager.useGlobalGuardTokens(...appGuards);
-        } else if (container.has(APP_GUARD)) {
-            routeManager.useGlobalGuardTokens(APP_GUARD);
-        }
-        const appPipes = loader.getAppProviderTokens(APP_PIPE);
-        if (appPipes.length > 0) {
-            routeManager.useGlobalPipeTokens(...appPipes);
-        } else if (container.has(APP_PIPE)) {
-            routeManager.useGlobalPipeTokens(APP_PIPE);
-        }
-        const appInterceptors = loader.getAppProviderTokens(APP_INTERCEPTOR);
-        if (appInterceptors.length > 0) {
-            routeManager.useGlobalInterceptorTokens(...appInterceptors);
-        } else if (container.has(APP_INTERCEPTOR)) {
-            routeManager.useGlobalInterceptorTokens(APP_INTERCEPTOR);
-        }
-        const appFilters = loader.getAppProviderTokens(APP_FILTER);
-        if (appFilters.length > 0) {
-            routeManager.useGlobalFilterTokens(...appFilters);
-        } else if (container.has(APP_FILTER)) {
-            routeManager.useGlobalFilterTokens(APP_FILTER);
-        }
-        const appMiddleware = loader.getAppProviderTokens(APP_MIDDLEWARE);
-        if (appMiddleware.length > 0) {
-            routeManager.useGlobalMiddlewareTokens(...appMiddleware);
-        } else if (container.has(APP_MIDDLEWARE)) {
-            routeManager.useGlobalMiddlewareTokens(APP_MIDDLEWARE);
-        }
-        const app = new VelaApplication(container, routeManager);
-        const instances = await loader.resolveAllInstances();
-        app.setInstances(instances);
-        await app.callOnModuleInit();
-        await app.callOnApplicationBootstrap();
-        await app.initRoutes();
-        return new TestingModule(app);
-    }
-}
-export class Test {
-    static createTestingModule(metadata) {
-        return new TestingModuleBuilder(metadata);
-    }
-}

package/dist/testing/testing.module.d.ts

@@ -1,9 +0,0 @@
-import type { VelaApplication } from '../application';
-import type { Token } from '../container/types';
-export declare class TestingModule {
-    private readonly app;
-    constructor(app: VelaApplication);
-    get<T>(token: Token<T>): T;
-    close(signal?: string): Promise<void>;
-    createNestApplication(): VelaApplication;
-}

package/dist/testing/testing.module.js

@@ -1,15 +0,0 @@
-export class TestingModule {
-    app;
-    constructor(app){
-        this.app = app;
-    }
-    get(token) {
-        return this.app.get(token);
-    }
-    async close(signal) {
-        await this.app.close(signal);
-    }
-    createNestApplication() {
-        return this.app;
-    }
-}