@velajs/vela 1.17.0 → 1.18.0

package/dist/http/argument-resolver.js

@@ -65,7 +65,7 @@ export class ArgumentResolver {
             const metadata = {
                 type: param.type,
                 data: param.name,
-                metatype: paramTypes?.[param.index]
+                metatype: param.metatype ?? paramTypes?.[param.index]
             };
             for (const pipe of pipes){
                 value = await pipe.transform(value, metadata);

package/dist/http/request-container.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from 'hono';
+import type { Container } from '../container/container';
+/**
+ * Returns the request-scoped child container for the current request.
+ *
+ * `@Inject(Container)` resolves the ROOT container (request children share the
+ * provider map and never rebind `Container`), so module authors who need
+ * request-scoped resolution from inside a handler, param-decorator factory, or
+ * scoped middleware must read the child seeded by RouteManager instead. The
+ * child is created before guards, pipes, params, and handlers run, so it is
+ * always present on the Vela request path.
+ *
+ * Throws outside a Vela-managed request rather than materializing an orphan
+ * child (mirrors the REQUEST_CONTEXT fail-fast).
+ */
+export declare function getRequestContainer(c: Context): Container;

package/dist/http/request-container.js

@@ -0,0 +1,19 @@
+/**
+ * Returns the request-scoped child container for the current request.
+ *
+ * `@Inject(Container)` resolves the ROOT container (request children share the
+ * provider map and never rebind `Container`), so module authors who need
+ * request-scoped resolution from inside a handler, param-decorator factory, or
+ * scoped middleware must read the child seeded by RouteManager instead. The
+ * child is created before guards, pipes, params, and handlers run, so it is
+ * always present on the Vela request path.
+ *
+ * Throws outside a Vela-managed request rather than materializing an orphan
+ * child (mirrors the REQUEST_CONTEXT fail-fast).
+ */ export function getRequestContainer(c) {
+    const container = c.get('container');
+    if (!container) {
+        throw new Error('getRequestContainer(c) can only be called inside a Vela-managed request — ' + 'the request child container is seeded by RouteManager when the request enters the pipeline.');
+    }
+    return container;
+}

package/dist/http/route.manager.js

@@ -405,7 +405,7 @@ export class RouteManager {
         // `await import(variable)` as a runtime import Cloudflare Workers cannot
         // resolve.
         const contributors = getRouteContributors();
-        for (const { controller, metadata } of this.controllers){
+        for (const { controller, metadata, routes } of this.controllers){
             for (const contributor of contributors){
                 const meta = getMetadata(contributor.claimsMetaKey, controller);
                 if (meta === undefined) continue;
@@ -419,10 +419,11 @@ export class RouteManager {
                     joinPaths
                 });
             }
-            // DX guard for the common mistake: @Crud() metadata present but the
-            // contributor package never imported.
-            if (getMetadata('vela:crud', controller) !== undefined && !contributors.some((c)=>c.claimsMetaKey === 'vela:crud')) {
-                throw new Error("@Crud() requires '@velajs/crud'. Install it: pnpm add @velajs/crud");
+            // DX warning for stale setups: @Crud() metadata but nothing produced a
+            // route — native @velajs/crud (>=1.18) stamps real routes at decoration
+            // time, and legacy bridges register a claiming contributor.
+            if (getMetadata('vela:crud', controller) !== undefined && routes.length === 0 && !contributors.some((c)=>c.claimsMetaKey === 'vela:crud')) {
+                console.warn(`[vela] ${controller.name} carries @Crud() metadata but produced no routes — ` + "install and import '@velajs/crud' (>=1.18), or remove the decorator.");
             }
         }
         return app;

package/dist/http/types.d.ts

@@ -23,6 +23,12 @@ export interface ParamMetadata {
     name?: string;
     pipes?: PipeType[];
     factory?: (data: unknown, ctx: import('hono').Context) => unknown;
+    /**
+     * Explicit param type for programmatic routes. Methods synthesized at
+     * runtime (e.g. `@Crud()` verb handlers) have no `design:paramtypes`, so
+     * ValidationPipe and the OpenAPI walk read this instead when present.
+     */
+    metatype?: unknown;
 }
 export interface ControllerRegistration {
     controller: Type;

package/dist/index.d.ts

@@ -16,6 +16,7 @@ export { signUrl, verifySignedUrl } from './crypto/signed-url';
 export type { SignedUrlOptions } from './crypto/signed-url';
 export { REQUEST_CONTEXT } from './http/request-context';
 export type { RequestContext } from './http/request-context';
+export { getRequestContainer } from './http/request-container';
 export { enableAmbientContainer, getCurrentContainer, getCurrentRequestContext, } from './http/ambient';
 export { Logger, LogLevel } from './services/index';
 export type { LoggerService, ContextProvider, Writer, LoggerLevelName } from './services/index';

package/dist/index.js

@@ -16,6 +16,9 @@ export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, All,
 export { signUrl, verifySignedUrl } from "./crypto/signed-url.js";
 // Request-scoped context primitive
 export { REQUEST_CONTEXT } from "./http/request-context.js";
+// Explicit request-child container access (for programmatic-route authors,
+// param-decorator factories, and scoped middleware)
+export { getRequestContainer } from "./http/request-container.js";
 // Opt-in ambient container access (ALS via hono/context-storage)
 export { enableAmbientContainer, getCurrentContainer, getCurrentRequestContext } from "./http/ambient.js";
 // Services

package/dist/live/index.d.ts

@@ -1,7 +1,7 @@
 export { LiveModule } from './live.module';
 export { LiveResolver, LiveQuery, getLiveQueries } from './live.decorators';
 export { LiveEngine, LIVE_SUBS_DATA_KEY, readPersistedLiveSubscriptions } from './live.engine';
-export { LiveInvalidation, localLive, stampCommitHeaders } from './live.invalidation';
+export { LiveInvalidation, localLive, perAppLiveDriver, stampCommitHeaders } from './live.invalidation';
 export { InMemoryCursorLog } from './live.cursor';
 export { encodeSubscriptionUpdate } from './live.delta';
 export { PresenceService, PresenceResolver, presenceTag, PRESENCE_ROSTER_QUERY } from './presence';

package/dist/live/index.js

@@ -6,7 +6,7 @@
 export { LiveModule } from "./live.module.js";
 export { LiveResolver, LiveQuery, getLiveQueries } from "./live.decorators.js";
 export { LiveEngine, LIVE_SUBS_DATA_KEY, readPersistedLiveSubscriptions } from "./live.engine.js";
-export { LiveInvalidation, localLive, stampCommitHeaders } from "./live.invalidation.js";
+export { LiveInvalidation, localLive, perAppLiveDriver, stampCommitHeaders } from "./live.invalidation.js";
 export { InMemoryCursorLog } from "./live.cursor.js";
 export { encodeSubscriptionUpdate } from "./live.delta.js";
 export { PresenceService, PresenceResolver, presenceTag, PRESENCE_ROSTER_QUERY } from "./presence.js";

package/dist/live/live.invalidation.d.ts

@@ -1,6 +1,24 @@
 import type { CommitStamp, InvalidationCommand, LiveDriver } from './live.types';
 /** Single-scope default driver: deliver straight to this process's engine. */
 export declare function localLive(): LiveDriver;
+/**
+ * Per-app wrapper around a (possibly SHARED) driver instance.
+ *
+ * A driver passed to `LiveModule.forRoot({ driver })` is a plain config object
+ * — and on Cloudflare the SAME app module (thus the same driver object)
+ * bootstraps in the Worker isolate AND inside each Durable Object, often
+ * within one isolate. Mutable per-app state must therefore never live on the
+ * driver itself: the DO flipping a shared `durableObjectLive()` into local
+ * mode would otherwise poison the Worker's engine, which then executes the
+ * DO's storage handle in the wrong request context ("Cannot perform I/O on
+ * behalf of a different request").
+ *
+ * The wrapper owns the per-app sink and the per-app local-mode flag; isolate-
+ * wide concerns (env capture) forward to the underlying driver. Platform init
+ * hooks (`_setLocalMode`, `_initializeEnv`) are exposed pass-through so
+ * platform packages can keep type-guarding on their presence.
+ */
+export declare function perAppLiveDriver(underlying: LiveDriver): LiveDriver;
 /**
  * The injectable invalidation surface for custom (non-CRUD) write paths:
  *

package/dist/live/live.invalidation.js

@@ -12,6 +12,49 @@ import { getContext } from "hono/context-storage";
         }
     };
 }
+/**
+ * Per-app wrapper around a (possibly SHARED) driver instance.
+ *
+ * A driver passed to `LiveModule.forRoot({ driver })` is a plain config object
+ * — and on Cloudflare the SAME app module (thus the same driver object)
+ * bootstraps in the Worker isolate AND inside each Durable Object, often
+ * within one isolate. Mutable per-app state must therefore never live on the
+ * driver itself: the DO flipping a shared `durableObjectLive()` into local
+ * mode would otherwise poison the Worker's engine, which then executes the
+ * DO's storage handle in the wrong request context ("Cannot perform I/O on
+ * behalf of a different request").
+ *
+ * The wrapper owns the per-app sink and the per-app local-mode flag; isolate-
+ * wide concerns (env capture) forward to the underlying driver. Platform init
+ * hooks (`_setLocalMode`, `_initializeEnv`) are exposed pass-through so
+ * platform packages can keep type-guarding on their presence.
+ */ export function perAppLiveDriver(underlying) {
+    let ownSink;
+    let localMode = false;
+    const cfHooks = underlying;
+    return {
+        get kind () {
+            return underlying.kind;
+        },
+        bind (sink) {
+            ownSink = sink;
+            underlying.bind(sink);
+        },
+        dispatch (cmd) {
+            if (localMode && ownSink) return ownSink.applyInvalidation(cmd);
+            return underlying.dispatch(cmd);
+        },
+        start: underlying.start ? ()=>underlying.start?.() : undefined,
+        stop: underlying.stop ? ()=>underlying.stop?.() : undefined,
+        // Platform hooks (Cloudflare): local mode is PER APP; env is per isolate.
+        _setLocalMode () {
+            localMode = true;
+        },
+        _initializeEnv (env) {
+            cfHooks._initializeEnv?.(env);
+        }
+    };
+}
 /**
  * The injectable invalidation surface for custom (non-CRUD) write paths:
  *

package/dist/live/live.module.js

@@ -1,7 +1,7 @@
 import { defineModule } from "../index.js";
 import { InMemoryCursorLog } from "./live.cursor.js";
 import { LiveEngine } from "./live.engine.js";
-import { LiveInvalidation, localLive } from "./live.invalidation.js";
+import { LiveInvalidation, localLive, perAppLiveDriver } from "./live.invalidation.js";
 import { LIVE_CURSOR_LOG, LIVE_DRIVER, LIVE_MODULE_OPTIONS } from "./live.tokens.js";
 import { PresenceResolver, PresenceService } from "./presence.js";
 /**
@@ -39,7 +39,11 @@ import { PresenceResolver, PresenceService } from "./presence.js";
                 },
                 {
                     provide: LIVE_DRIVER,
-                    useFactory: (o)=>o.driver ?? localLive(),
+                    // Wrapped per app: user-supplied drivers are shared config objects
+                    // (the same module bootstraps in the Worker AND in each Durable
+                    // Object), so per-app sink/mode state lives in the wrapper — see
+                    // perAppLiveDriver.
+                    useFactory: (o)=>perAppLiveDriver(o.driver ?? localLive()),
                     inject: [
                         OPTIONS
                     ]

package/dist/openapi/document.js

@@ -39,7 +39,7 @@ function isDtoClass(value) {
     return typeof value === 'function' && value.schema != null;
 }
 function getParamSchema(param, paramtypes, registry) {
-    const metatype = paramtypes?.[param.index];
+    const metatype = param.metatype ?? paramtypes?.[param.index];
     if (!metatype) return undefined;
     if (isDtoClass(metatype)) {
         return registry.ref(metatype);
@@ -51,7 +51,7 @@ function getParamSchema(param, paramtypes, registry) {
     return undefined;
 }
 function isParamOptional(param, paramtypes) {
-    const metatype = paramtypes?.[param.index];
+    const metatype = param.metatype ?? paramtypes?.[param.index];
     if (metatype?.schema) {
         return isOptional(metatype.schema);
     }

package/dist/registry/types.d.ts

@@ -30,6 +30,12 @@ export interface ParameterMetadata {
     name?: string;
     pipes?: PipeType[];
     factory?: (data: unknown, ctx: Context) => unknown;
+    /**
+     * Explicit param type for programmatic routes. Methods synthesized at
+     * runtime (e.g. `@Crud()` verb handlers) have no `design:paramtypes`, so
+     * ValidationPipe and the OpenAPI walk read this instead when present.
+     */
+    metatype?: unknown;
 }
 export interface HttpHandlerMeta {
     httpCode?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velajs/vela",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "description": "NestJS-compatible framework for edge runtimes, powered by Hono",
   "type": "module",
   "main": "./dist/index.js",