@velajs/vela 1.8.0 → 1.8.2

package/CHANGELOG.md

@@ -1,15 +1,15 @@
 # Changelog
 
-## 1.7.0 (2026-05-14)
+## 1.8.1 (2026-05-14)
 
-### New
+### Revert
 
-- **`OnFirstRequest` lifecycle hook.** Fires exactly once on the first incoming HTTP request, AFTER user-supplied middleware (so runtime adapters like `@velajs/cloudflare`'s binding-init can run first) and BEFORE route handlers. Bridges module-load and request-time semantics — the canonical seam for state that depends on values only available at request time (Cloudflare D1/KV/R2 bindings, Deno Deploy env, etc.). Auto-fired by a global middleware vela installs after user middleware; non-HTTP consumers can trigger it manually via `app.callOnFirstRequest()`. Concurrency-safe: vela memoizes the promise so parallel first requests share a single fire.
+- **`OnFirstRequest` lifecycle hook removed.** Shipped in 1.8.0 to bridge module-load and request-time semantics for runtime-bound state (Cloudflare bindings, etc.). In practice, consumers can achieve the same deferral with a plain `@Injectable()` service holding the state as a lazy-cached field via a getter — the idiomatic NestJS pattern, no framework primitive required. Adding a lifecycle hook with zero in-tree consumers was YAGNI; reverting before it accumulates dependents. Apps that pinned to 1.8.0 and used `OnFirstRequest` should migrate to the lazy-service pattern before upgrading.
 
 ### Notes
 
-- Edge-clean addition — no `node:*`, no `Buffer`, no `setInterval`; the hook is just `() => void | Promise<void>` wired into Hono's middleware chain.
-- Backwards-compatible. Existing apps unaffected: the new middleware only fires hooks if any registered instance implements `OnFirstRequest`, and the implementation is a no-op otherwise.
+- 1.8.0 remains published on npm but no longer the `latest` tag.
+- `OnApplicationBootstrap`, `OnModuleInit`, and the existing lifecycle hooks are unchanged.
 
 ## [1.6.0]
 

package/dist/application.d.ts

@@ -9,7 +9,6 @@ export declare class VelaApplication {
     private readonly routeManager;
     private instances;
     private honoApp;
-    private firstRequestPromise;
     constructor(container: Container, routeManager: RouteManager);
     /** Pre-build routes (handles async CRUD imports). Called by VelaFactory. */
     initRoutes(): Promise<void>;
@@ -37,14 +36,5 @@ export declare class VelaApplication {
     mountOpenApi(options: MountOpenApiOptions): this;
     callOnModuleInit(): Promise<void>;
     callOnApplicationBootstrap(): Promise<void>;
-    /**
-     * Fire `OnFirstRequest` hooks exactly once across the application's
-     * lifetime. Auto-invoked by a global middleware on the first HTTP request;
-     * also safe to call manually from non-HTTP entry points (CLI, tests).
-     *
-     * Concurrent calls share the same in-flight promise — vela guarantees
-     * each instance's `onFirstRequest()` runs at most once.
-     */
-    callOnFirstRequest(): Promise<void>;
     close(signal?: string): Promise<void>;
 }

package/dist/application.js

@@ -1,13 +1,10 @@
-import { hasBeforeApplicationShutdown, hasOnApplicationBootstrap, hasOnApplicationShutdown, hasOnFirstRequest, hasOnModuleDestroy, hasOnModuleInit } from "./lifecycle/index.js";
+import { hasBeforeApplicationShutdown, hasOnApplicationBootstrap, hasOnApplicationShutdown, hasOnModuleDestroy, hasOnModuleInit } from "./lifecycle/index.js";
 import { renderScalarUi } from "./openapi/scalar-ui.js";
 export class VelaApplication {
     container;
     routeManager;
     instances = [];
     honoApp = null;
-    // Memoizes the first-request hook fire. Concurrent first requests share
-    // this promise so the hook runs exactly once.
-    firstRequestPromise;
     constructor(container, routeManager){
         this.container = container;
         this.routeManager = routeManager;
@@ -92,25 +89,6 @@ export class VelaApplication {
             }
         }
     }
-    /**
-   * Fire `OnFirstRequest` hooks exactly once across the application's
-   * lifetime. Auto-invoked by a global middleware on the first HTTP request;
-   * also safe to call manually from non-HTTP entry points (CLI, tests).
-   *
-   * Concurrent calls share the same in-flight promise — vela guarantees
-   * each instance's `onFirstRequest()` runs at most once.
-   */ callOnFirstRequest() {
-        if (!this.firstRequestPromise) {
-            this.firstRequestPromise = (async ()=>{
-                for (const instance of this.instances){
-                    if (hasOnFirstRequest(instance)) {
-                        await instance.onFirstRequest();
-                    }
-                }
-            })();
-        }
-        return this.firstRequestPromise;
-    }
     async close(signal) {
         const reversed = [
             ...this.instances

package/dist/container/index.d.ts

@@ -3,4 +3,4 @@ export { Injectable, Inject, Optional, isInjectable, getScope } from './decorato
 export { InjectionToken, ForwardRef, forwardRef, ModuleVisibilityError, MultipleProvidersFoundError, ROOT_MODULE_ID, } from './types';
 export { ModuleRef } from './module-ref';
 export { mixin } from './mixin';
-export type { Type, Token, InjectableOptions, InjectMetadata, ProviderOptions, ProviderRegistration, InjectionTokenOptions, ModuleScope, ContainerOptions, Diagnostics, } from './types';
+export type { Type, Token, InferToken, InferTokens, InjectableOptions, InjectMetadata, ProviderOptions, ProviderRegistration, InjectionTokenOptions, ModuleScope, ContainerOptions, Diagnostics, } from './types';

package/dist/container/types.d.ts

@@ -16,6 +16,28 @@ export declare class ForwardRef<T = unknown> {
 }
 export declare function forwardRef<T>(factory: () => Token<T>): ForwardRef<T>;
 export type Token<T = any> = Type<T> | InjectionToken<T> | string | symbol;
+/**
+ * Maps a single DI `Token<T>` to its resolved value type at the type level:
+ * - `InjectionToken<T>`           → `T`
+ * - `Type<T>` / `Constructor<T>`  → `T` (the instance type)
+ * - `ForwardRef<T>`               → `T`
+ * - `string` / `symbol`           → `unknown` (runtime-only tokens carry no
+ *                                   static type info; the consumer asserts).
+ *
+ * Used by `AsyncModuleOptions` to give `useFactory` parameters their real
+ * types based on the literal `inject` tuple — without `as const` at the call
+ * site (relies on the `const` type parameter on the consuming generic).
+ */
+export type InferToken<T> = T extends InjectionToken<infer U> ? U : T extends ForwardRef<infer U> ? U : T extends abstract new (...args: any[]) => infer U ? U : unknown;
+/**
+ * Map every position of a `Token[]` tuple to its resolved value type.
+ * Pairs with `const Inject extends readonly Token<unknown>[]` generics to
+ * give `useFactory(...deps)` parameter types inferred from the literal
+ * `inject` array.
+ */
+export type InferTokens<T extends readonly unknown[]> = {
+    [K in keyof T]: InferToken<T[K]>;
+};
 export interface InjectableOptions {
     scope?: Scope;
 }
@@ -30,7 +52,7 @@ export interface ProviderOptions<T = unknown> {
     useValue?: T;
     useFactory?: (...args: any[]) => T | Promise<T>;
     useClass?: Type<T>;
-    inject?: Token[];
+    inject?: readonly Token[];
     useExisting?: Token<T>;
 }
 export interface ProviderRegistration<T = unknown> {
@@ -46,7 +68,7 @@ export interface ProviderRegistration<T = unknown> {
     useValue?: T;
     useFactory?: (...args: any[]) => T | Promise<T>;
     useClass?: Type<T>;
-    inject?: Token[];
+    inject?: readonly Token[];
     useExisting?: Token<T>;
 }
 export interface ModuleScope {

package/dist/factory.js

@@ -6,18 +6,6 @@ export const VelaFactory = {
         const app = new VelaApplication(container, routeManager);
         const instances = await loader.resolveAllInstances();
         app.setInstances(instances);
-        // Register the first-request middleware AFTER user-supplied middleware
-        // (registered by bootstrap from `options.middleware`). Ordering matters:
-        // runtime adapters like `@velajs/cloudflare` install binding-init
-        // middleware that must run BEFORE OnFirstRequest hooks read those
-        // bindings. Vela's middleware is appended last → fires after all user
-        // middleware, before route handlers (which are registered separately).
-        routeManager.useGlobalMiddleware({
-            use: async (_c, next)=>{
-                await app.callOnFirstRequest();
-                await next();
-            }
-        });
         await app.callOnModuleInit();
         await app.callOnApplicationBootstrap();
         // Build routes (async — supports CRUD integration with dynamic imports)

package/dist/index.d.ts

@@ -7,7 +7,7 @@ export type { BootstrapOptions, BootstrapResult } from './factory/bootstrap';
 export { createOpenApiDocument, ApiDoc, ApiTags, ApiResponse, zodToJsonSchema, } from './openapi/index';
 export type { OpenApiDocument, OpenApiInfo, OpenApiOperation, OpenApiParameter, OpenApiPathItem, OpenApiRequestBody, OpenApiResponse, ApiDocMetadata, ApiResponseEntry, ApiResponseOptions, CreateOpenApiDocumentOptions, HttpVerb, JsonSchema, } from './openapi/index';
 export { Container, Injectable, Inject, Optional, InjectionToken, ForwardRef, forwardRef, ModuleRef, ModuleVisibilityError, MultipleProvidersFoundError, ROOT_MODULE_ID, mixin, } from './container/index';
-export type { Type, Token, InjectableOptions, ProviderOptions, ModuleScope, ContainerOptions, Diagnostics, } from './container/index';
+export type { Type, Token, InferToken, InferTokens, InjectableOptions, ProviderOptions, ModuleScope, ContainerOptions, Diagnostics, } from './container/index';
 export { METADATA_KEYS, HttpMethod, ParamType, Scope } from './constants';
 export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, All, Sse, Param, Query, Body, Headers, Req, Res, Ip, Cookie, Cookies, RawBody, HttpCode, Header, Redirect, createParamDecorator, createLazyParamDecorator, applyDecorators, } from './http/index';
 export { REQUEST_CONTEXT } from './http/request-context';
@@ -41,7 +41,7 @@ export type { Constructor, MiddlewareType, GuardType, PipeType, InterceptorType,
 export { ParseIntPipe, ParseFloatPipe, ParseBoolPipe, ParseUUIDPipe, ParseEnumPipe, ParseArrayPipe, DefaultValuePipe, RequiredPipe, ZodValidationPipe, } from './pipeline/index';
 export type { ParseUUIDPipeOptions, ParseArrayPipeOptions } from './pipeline/index';
 export { HttpException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException, MethodNotAllowedException, NotAcceptableException, RequestTimeoutException, ConflictException, GoneException, PayloadTooLargeException, UnsupportedMediaTypeException, UnprocessableEntityException, TooManyRequestsException, InternalServerErrorException, NotImplementedException, BadGatewayException, ServiceUnavailableException, GatewayTimeoutException, } from './errors/index';
-export type { OnModuleInit, OnApplicationBootstrap, OnFirstRequest, OnModuleDestroy, OnApplicationShutdown, BeforeApplicationShutdown, } from './lifecycle/index';
+export type { OnModuleInit, OnApplicationBootstrap, OnModuleDestroy, OnApplicationShutdown, BeforeApplicationShutdown, } from './lifecycle/index';
 export { MetadataRegistry } from './registry/metadata.registry';
 export { createZodDto, ValidationPipe } from './validation/index';
 export type { CreateZodDtoOptions } from './validation/index';

package/dist/lifecycle/index.d.ts

@@ -4,25 +4,6 @@ export interface OnModuleInit {
 export interface OnApplicationBootstrap {
     onApplicationBootstrap(): void | Promise<void>;
 }
-/**
- * Fires exactly once, on the first incoming HTTP request, AFTER user-supplied
- * middleware (so binding initializers like `@velajs/cloudflare`'s env capture
- * run first) and BEFORE route handlers. The hook bridges module-load and
- * request-time semantics — use it for state that depends on values only
- * available at request time (Cloudflare bindings, Deno Deploy env, etc.).
- *
- * Concurrency: vela memoizes the call. Concurrent first requests all await
- * the same promise; the hook runs exactly once.
- *
- * Non-HTTP consumers (CLI, tests) can trigger it manually via
- * `app.callOnFirstRequest()`.
- *
- * Edge-safe: the hook itself is just `() => void | Promise<void>`. The
- * runtime contract is async/Promise — no Node-only APIs are involved.
- */
-export interface OnFirstRequest {
-    onFirstRequest(): void | Promise<void>;
-}
 export interface OnModuleDestroy {
     onModuleDestroy(): void | Promise<void>;
 }
@@ -34,7 +15,6 @@ export interface BeforeApplicationShutdown {
 }
 export declare function hasOnModuleInit(instance: unknown): instance is OnModuleInit;
 export declare function hasOnApplicationBootstrap(instance: unknown): instance is OnApplicationBootstrap;
-export declare function hasOnFirstRequest(instance: unknown): instance is OnFirstRequest;
 export declare function hasOnModuleDestroy(instance: unknown): instance is OnModuleDestroy;
 export declare function hasBeforeApplicationShutdown(instance: unknown): instance is BeforeApplicationShutdown;
 export declare function hasOnApplicationShutdown(instance: unknown): instance is OnApplicationShutdown;

package/dist/lifecycle/index.js

@@ -4,9 +4,6 @@ export function hasOnModuleInit(instance) {
 export function hasOnApplicationBootstrap(instance) {
     return instance !== null && typeof instance === 'object' && typeof instance.onApplicationBootstrap === 'function';
 }
-export function hasOnFirstRequest(instance) {
-    return instance !== null && typeof instance === 'object' && typeof instance.onFirstRequest === 'function';
-}
 export function hasOnModuleDestroy(instance) {
     return instance !== null && typeof instance === 'object' && typeof instance.onModuleDestroy === 'function';
 }

package/dist/registry/types.d.ts

@@ -1,7 +1,7 @@
 import type { Context } from 'hono';
 import type { CanActivate, ExceptionFilter, NestInterceptor, NestMiddleware, PipeTransform } from '../pipeline/types';
-import type { Constructor, ForwardRef, InjectionToken, ProviderOptions, Token, Type } from '../container/types';
-export type { Constructor, ForwardRef, InjectionToken, ProviderOptions, Token, Type };
+import type { Constructor, ForwardRef, InferToken, InferTokens, InjectionToken, ProviderOptions, Token, Type } from '../container/types';
+export type { Constructor, ForwardRef, InferToken, InferTokens, InjectionToken, ProviderOptions, Token, Type };
 export type ComponentType = 'middleware' | 'guard' | 'pipe' | 'interceptor' | 'filter';
 export type MiddlewareType = Type<NestMiddleware> | NestMiddleware;
 export type GuardType = Type<CanActivate> | CanActivate;
@@ -38,10 +38,30 @@ export interface HttpHandlerMeta {
     };
 }
 export type ModuleImport = Type | DynamicModule | ForwardRef;
-export interface AsyncModuleOptions<T = unknown> {
+/**
+ * Async module options with **type-inferred `useFactory` parameters**.
+ *
+ * The `Inject` generic captures the literal `inject` tuple via `const` type
+ * parameter inference at the call site (TS 5.0+ — vela already requires it).
+ * `useFactory`'s parameter types are computed from that tuple via
+ * `InferTokens<Inject>`, so:
+ *
+ * ```ts
+ * SomeModule.forRootAsync({
+ *   inject: [D1Service, ConfigService],   // captured as readonly [typeof D1Service, typeof ConfigService]
+ *   useFactory: (d1, config) => { ... },  // d1: D1Service, config: ConfigService — inferred
+ * });
+ * ```
+ *
+ * Backwards compatible: when `inject` isn't a literal tuple (or is omitted),
+ * `Inject` falls back to `readonly Token<unknown>[]`, `InferTokens` resolves
+ * to `unknown[]`, and `useFactory` accepts variadic `unknown[]` — the prior
+ * loose-typing behavior. Existing callers don't break.
+ */
+export interface AsyncModuleOptions<T = unknown, Inject extends readonly Token<unknown>[] = readonly Token<unknown>[]> {
     imports?: ModuleImport[];
-    useFactory: (...args: any[]) => T | Promise<T>;
-    inject?: Token[];
+    inject?: Inject;
+    useFactory: (...args: InferTokens<Inject>) => T | Promise<T>;
 }
 export interface DynamicModule {
     module: Type;

package/package.json

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