@velajs/vela 1.8.1 → 1.8.2

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/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';

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.1",
+  "version": "1.8.2",
   "description": "NestJS-compatible framework for edge runtimes, powered by Hono",
   "type": "module",
   "main": "./dist/index.js",