@velajs/testing 0.4.0 → 0.5.1

package/dist/testing-module.builder.js

@@ -1,160 +0,0 @@
-import { DiscoveryService, REQUEST_CONTEXT, Scope } from "@velajs/vela";
-import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_MIDDLEWARE, APP_PIPE, Container, MetadataRegistry, ModuleLoader, ModuleRef, RouteManager, VelaApplication, bindAppProviders } from "@velajs/vela/internal";
-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) {
-        const idx = this.overrides.findIndex((o)=>o.token === entry.token);
-        if (idx !== -1) {
-            this.overrides[idx] = entry;
-        } else {
-            this.overrides.push(entry);
-        }
-    }
-    async compile() {
-        let TestRootModule = class TestRootModule {
-        };
-        MetadataRegistry.setModuleOptions(TestRootModule, {
-            imports: this.metadata.imports,
-            providers: this.metadata.providers,
-            controllers: this.metadata.controllers,
-            exports: this.metadata.exports
-        });
-        const container = new Container();
-        // Replicate bootstrap()'s global token setup so request-pipeline tests
-        // can resolve REQUEST_CONTEXT, ModuleRef, and the APP_* sentinel tokens
-        // from any module scope. Without this, guards / decorators that inject
-        // REQUEST_CONTEXT through ExecutionContext fail with "no provider"
-        // when the request enters the pipeline. See vela/src/factory/bootstrap.ts.
-        container.register({
-            provide: Container,
-            useValue: container
-        });
-        container.markGlobalToken(Container);
-        container.register({
-            provide: ModuleRef,
-            useFactory: (c)=>new ModuleRef(c),
-            inject: [
-                Container
-            ]
-        });
-        container.markGlobalToken(ModuleRef);
-        // Decorator-driven discovery — global so any provider can inject it, and so
-        // callOnApplicationBootstrap() reuses this instance instead of self-building
-        // one. Mirrors vela/src/factory/bootstrap.ts.
-        container.register({
-            provide: DiscoveryService,
-            useFactory: (c)=>new DiscoveryService(c),
-            inject: [
-                Container
-            ]
-        });
-        container.markGlobalToken(DiscoveryService);
-        for (const t of [
-            APP_GUARD,
-            APP_PIPE,
-            APP_INTERCEPTOR,
-            APP_FILTER,
-            APP_MIDDLEWARE
-        ]){
-            container.markGlobalToken(t);
-        }
-        // REQUEST_CONTEXT is seeded into each per-request child container by
-        // RouteManager via setRequestInstance. Registering with a throw-factory
-        // here ensures findRegistration succeeds (so the child's cached request
-        // instance is returned) while surfacing a clear error if the token is
-        // ever resolved outside the request path.
-        container.register({
-            provide: REQUEST_CONTEXT,
-            scope: Scope.REQUEST,
-            useFactory: ()=>{
-                throw new Error('REQUEST_CONTEXT can only be resolved inside a request — ' + 'it is seeded by RouteManager when the request enters the pipeline.');
-            }
-        });
-        container.markGlobalToken(REQUEST_CONTEXT);
-        // Pre-register at root so `moduleRef.get(token)` and framework-internal
-        // resolves (instantiate(guard, container) with no requestingModuleId) see
-        // the override immediately.
-        for (const override of this.overrides){
-            container.register(override.provider);
-        }
-        const routeManager = new RouteManager(container);
-        const loader = new ModuleLoader(container, routeManager);
-        loader.load(TestRootModule);
-        // Force-apply overrides into every module bucket that already holds the
-        // token (plus root). Without this, controller constructor-injection (which
-        // passes requestingModuleId to findRegistration) finds the module's own
-        // registration first and never consults the root override. The default
-        // 'all-existing' buckets replace every non-root bucket holding the token
-        // and re-register at root — the supported form of the old private loop.
-        for (const override of this.overrides){
-            container.replaceProvider(override.provider);
-        }
-        bindAppProviders(routeManager, container, loader);
-        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, container);
-    }
-}

package/dist/testing-module.d.ts

@@ -1,10 +0,0 @@
-import type { Token, VelaApplication } from '@velajs/vela';
-import type { Container } from '@velajs/vela/internal';
-export declare class TestingModule {
-    private readonly app;
-    private readonly container;
-    constructor(app: VelaApplication, container: Container);
-    get<T>(token: Token<T>): T;
-    createApplication(): Promise<VelaApplication>;
-    close(signal?: string): Promise<void>;
-}

package/dist/testing-module.js

@@ -1,18 +0,0 @@
-export class TestingModule {
-    app;
-    container;
-    constructor(app, container){
-        this.app = app;
-        this.container = container;
-    }
-    get(token) {
-        return this.container.resolve(token);
-    }
-    async createApplication() {
-        await this.app.initRoutes();
-        return this.app;
-    }
-    async close(signal) {
-        await this.app.close(signal);
-    }
-}