@velajs/testing 0.2.0 → 0.2.1

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.2.1 (2026-05-14)
+
+### Fixes
+
+- **`compile()` now replicates `bootstrap()`'s global token setup.** Registers `Container`, `ModuleRef`, and `REQUEST_CONTEXT` as global tokens (the last is the canonical seam for the per-request bag that `RouteManager.setRequestInstance` populates). Marks `APP_GUARD/PIPE/INTERCEPTOR/FILTER/MIDDLEWARE` as global so multi-provider pipeline registration via `bindAppProviders` resolves cleanly. Before this fix, guards / services that injected `REQUEST_CONTEXT` (the documented `@CurrentUser` lazy-decorator pattern) crashed at request time with "REQUEST_CONTEXT can only be resolved inside a request". New test pins the behavior end-to-end.
+- **Overrides now win for controller-internal constructor injection.** Pre-registering an override at the root container's `__root__` bucket only beat framework-internal lookups (no `requestingModuleId`). Controller constructor injection passes the controller's module id, which finds the module's own registration before the root override and short-circuits. The builder now post-processes after `loader.load()` and overwrites the registration in every module bucket that already holds the token.
+
+### Breaking changes
+
+- **`@velajs/vela` peer bumped to `>=1.6.0`.** Needs `REQUEST_CONTEXT` and `createLazyParamDecorator` re-exports (added in vela 1.6.0).
+
 ## 0.2.0 (2026-04-30)
 
 Bugs fixed, rebuilt on `@velajs/vela/internal`, no more `reflect-metadata` dep.

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

@@ -1,4 +1,4 @@
-import type { ModuleOptions, Token, Type } from '@velajs/vela';
+import { type ModuleOptions, type Token, type Type } from '@velajs/vela';
 import { TestingModule } from './testing-module.js';
 export declare class OverrideBy {
     private readonly builder;

package/dist/testing-module.builder.js

@@ -1,4 +1,5 @@
-import { ComponentManager, Container, MetadataRegistry, ModuleLoader, RouteManager, VelaApplication, bindAppProviders } from "@velajs/vela/internal";
+import { REQUEST_CONTEXT, Scope } from "@velajs/vela";
+import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR, APP_MIDDLEWARE, APP_PIPE, ComponentManager, Container, MetadataRegistry, ModuleLoader, ModuleRef, RouteManager, VelaApplication, bindAppProviders } from "@velajs/vela/internal";
 import { TestingModule } from "./testing-module.js";
 export class OverrideBy {
     builder;
@@ -78,11 +79,49 @@ export class TestingModuleBuilder {
             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
         });
-        // Register overrides BEFORE module loading so ModuleLoader skips originals.
+        container.markGlobalToken(Container);
+        container.register({
+            provide: ModuleRef,
+            useFactory: (c)=>new ModuleRef(c),
+            inject: [
+                Container
+            ]
+        });
+        container.markGlobalToken(ModuleRef);
+        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);
         }
@@ -90,6 +129,25 @@ export class TestingModuleBuilder {
         ComponentManager.init(container);
         const loader = new ModuleLoader(container, routeManager);
         loader.load(TestRootModule);
+        // Force-apply overrides into every module bucket that already holds the
+        // token. Without this, controller constructor-injection (which passes
+        // requestingModuleId to findRegistration) finds the module's own
+        // registration first and never consults the root override. Re-registering
+        // with the module's id overwrites the bucket entry.
+        //
+        // Reaches into Container internals (the `providers` map) until vela
+        // exposes a public "force replace across all scopes" API. The shape is
+        // stable in vela 1.6.x; if this breaks under a future vela version, raise
+        // a vela API request before working around again.
+        const providersMap = container.providers;
+        for (const override of this.overrides){
+            for (const [moduleId, bucket] of providersMap){
+                if (moduleId === '__root__') continue;
+                if (bucket.has(override.token)) {
+                    container.register(override.provider, moduleId);
+                }
+            }
+        }
         bindAppProviders(routeManager, container, loader);
         const app = new VelaApplication(container, routeManager);
         const instances = await loader.resolveAllInstances();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velajs/testing",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Testing utilities for Vela framework",
   "type": "module",
   "main": "./dist/index.js",
@@ -47,14 +47,14 @@
     "node": ">=20"
   },
   "peerDependencies": {
-    "@velajs/vela": ">=1.1.0",
+    "@velajs/vela": ">=1.6.0",
     "hono": ">=4"
   },
   "devDependencies": {
     "@swc/cli": "^0.8.0",
     "@swc/core": "^1.15.11",
     "@types/bun": "latest",
-    "@velajs/vela": "^1.1.0",
+    "@velajs/vela": "^1.6.0",
     "hono": "^4",
     "typescript": "^5",
     "unplugin-swc": "^1.5.9",