@velajs/vela 0.3.0 → 0.4.1

package/dist/health/health.http.d.ts

@@ -0,0 +1,14 @@
+import { HealthIndicatorService } from './health.indicator';
+import type { HealthIndicatorResult, ResponseCheckCallback } from './health.types';
+export interface HttpPingOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    expectedStatus?: number;
+}
+export declare class HttpHealthIndicator {
+    private indicator;
+    constructor(indicator: HealthIndicatorService);
+    pingCheck(key: string, url: string, options?: HttpPingOptions): Promise<HealthIndicatorResult>;
+    responseCheck(key: string, url: string, callback: ResponseCheckCallback, options?: HttpPingOptions): Promise<HealthIndicatorResult>;
+}

package/dist/health/health.http.js

@@ -0,0 +1,75 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+import { Injectable } from "../container/index.js";
+import { HealthIndicatorService } from "./health.indicator.js";
+export class HttpHealthIndicator {
+    indicator;
+    constructor(indicator){
+        this.indicator = indicator;
+    }
+    async pingCheck(key, url, options) {
+        const { method = 'GET', headers, timeout = 5000, expectedStatus } = options ?? {};
+        try {
+            const response = await fetch(url, {
+                method,
+                headers,
+                signal: AbortSignal.timeout(timeout)
+            });
+            const statusCode = response.status;
+            const isHealthy = expectedStatus !== undefined ? statusCode === expectedStatus : statusCode >= 200 && statusCode < 300;
+            if (isHealthy) {
+                return this.indicator.check(key).up({
+                    statusCode
+                });
+            }
+            return this.indicator.check(key).down({
+                statusCode,
+                message: response.statusText
+            });
+        } catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            return this.indicator.check(key).down({
+                message
+            });
+        }
+    }
+    async responseCheck(key, url, callback, options) {
+        const { method = 'GET', headers, timeout = 5000 } = options ?? {};
+        try {
+            const response = await fetch(url, {
+                method,
+                headers,
+                signal: AbortSignal.timeout(timeout)
+            });
+            const statusCode = response.status;
+            const isHealthy = await callback(response);
+            if (isHealthy) {
+                return this.indicator.check(key).up({
+                    statusCode
+                });
+            }
+            return this.indicator.check(key).down({
+                statusCode
+            });
+        } catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            return this.indicator.check(key).down({
+                message
+            });
+        }
+    }
+}
+HttpHealthIndicator = _ts_decorate([
+    Injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof HealthIndicatorService === "undefined" ? Object : HealthIndicatorService
+    ])
+], HttpHealthIndicator);

package/dist/health/health.indicator.d.ts

@@ -0,0 +1,9 @@
+import type { HealthIndicatorResult } from './health.types';
+interface HealthIndicatorBuilder {
+    up(data?: Record<string, unknown>): HealthIndicatorResult;
+    down(data?: Record<string, unknown>): HealthIndicatorResult;
+}
+export declare class HealthIndicatorService {
+    check(key: string): HealthIndicatorBuilder;
+}
+export {};

package/dist/health/health.indicator.js

@@ -0,0 +1,32 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { Injectable } from "../container/index.js";
+export class HealthIndicatorService {
+    check(key) {
+        return {
+            up (data) {
+                return {
+                    [key]: {
+                        status: 'up',
+                        ...data
+                    }
+                };
+            },
+            down (data) {
+                return {
+                    [key]: {
+                        status: 'down',
+                        ...data
+                    }
+                };
+            }
+        };
+    }
+}
+HealthIndicatorService = _ts_decorate([
+    Injectable()
+], HealthIndicatorService);

package/dist/health/health.module.d.ts

@@ -0,0 +1,2 @@
+export declare class HealthModule {
+}

package/dist/health/health.module.js

@@ -0,0 +1,26 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { Module } from "../module/index.js";
+import { HealthCheckService } from "./health.service.js";
+import { HealthIndicatorService } from "./health.indicator.js";
+import { HttpHealthIndicator } from "./health.http.js";
+export class HealthModule {
+}
+HealthModule = _ts_decorate([
+    Module({
+        providers: [
+            HealthCheckService,
+            HealthIndicatorService,
+            HttpHealthIndicator
+        ],
+        exports: [
+            HealthCheckService,
+            HealthIndicatorService,
+            HttpHealthIndicator
+        ]
+    })
+], HealthModule);

package/dist/health/health.service.d.ts

@@ -0,0 +1,7 @@
+import type { BeforeApplicationShutdown } from '../lifecycle/index';
+import type { HealthCheckResult, HealthIndicatorFunction } from './health.types';
+export declare class HealthCheckService implements BeforeApplicationShutdown {
+    private isShuttingDown;
+    beforeApplicationShutdown(): void;
+    check(indicators: HealthIndicatorFunction[]): Promise<HealthCheckResult>;
+}

package/dist/health/health.service.js

@@ -0,0 +1,65 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { Injectable } from "../container/index.js";
+import { ServiceUnavailableException } from "../errors/http-exception.js";
+export class HealthCheckService {
+    isShuttingDown = false;
+    beforeApplicationShutdown() {
+        this.isShuttingDown = true;
+    }
+    async check(indicators) {
+        if (this.isShuttingDown) {
+            const result = {
+                status: 'shutting_down',
+                info: {},
+                error: {},
+                details: {}
+            };
+            throw new ServiceUnavailableException('Service Unavailable', result);
+        }
+        const results = await Promise.allSettled(indicators.map((fn)=>fn()));
+        const info = {};
+        const error = {};
+        const details = {};
+        for (const result of results){
+            if (result.status === 'fulfilled') {
+                const indicatorResult = result.value;
+                for (const [key, value] of Object.entries(indicatorResult)){
+                    details[key] = value;
+                    if (value.status === 'up') {
+                        info[key] = value;
+                    } else {
+                        error[key] = value;
+                    }
+                }
+            } else {
+                const message = result.reason instanceof Error ? result.reason.message : 'Health check failed';
+                const key = 'unknown';
+                const value = {
+                    status: 'down',
+                    message
+                };
+                details[key] = value;
+                error[key] = value;
+            }
+        }
+        const status = Object.keys(error).length > 0 ? 'error' : 'ok';
+        const checkResult = {
+            status,
+            info,
+            error,
+            details
+        };
+        if (status === 'error') {
+            throw new ServiceUnavailableException('Service Unavailable', checkResult);
+        }
+        return checkResult;
+    }
+}
+HealthCheckService = _ts_decorate([
+    Injectable()
+], HealthCheckService);

package/dist/health/health.types.d.ts

@@ -0,0 +1,15 @@
+export type HealthCheckStatus = 'ok' | 'error' | 'shutting_down';
+export interface HealthIndicatorResult {
+    [key: string]: {
+        status: 'up' | 'down';
+        [key: string]: unknown;
+    };
+}
+export interface HealthCheckResult {
+    status: HealthCheckStatus;
+    info: HealthIndicatorResult;
+    error: HealthIndicatorResult;
+    details: HealthIndicatorResult;
+}
+export type HealthIndicatorFunction = () => Promise<HealthIndicatorResult>;
+export type ResponseCheckCallback = (response: Response) => boolean | Promise<boolean>;

package/dist/health/health.types.js

@@ -0,0 +1 @@
+export { };

package/dist/health/index.d.ts

@@ -0,0 +1,6 @@
+export { HealthModule } from './health.module';
+export { HealthCheckService } from './health.service';
+export { HealthIndicatorService } from './health.indicator';
+export { HttpHealthIndicator } from './health.http';
+export type { HealthCheckResult, HealthCheckStatus, HealthIndicatorResult, HealthIndicatorFunction, ResponseCheckCallback, } from './health.types';
+export type { HttpPingOptions } from './health.http';

package/dist/health/index.js

@@ -0,0 +1,4 @@
+export { HealthModule } from "./health.module.js";
+export { HealthCheckService } from "./health.service.js";
+export { HealthIndicatorService } from "./health.indicator.js";
+export { HttpHealthIndicator } from "./health.http.js";

package/dist/index.d.ts

@@ -18,6 +18,10 @@ export { EventEmitterModule, EventEmitter, EventEmitterSubscriber, OnEvent, ON_E
 export type { EventHandler, OnEventMetadata } from './event-emitter/index';
 export { ScheduleModule, ScheduleRegistry, ScheduleExecutor, Cron, Interval, SCHEDULE_MODULE_OPTIONS, CRON_METADATA, INTERVAL_METADATA, } from './schedule/index';
 export type { RegisteredCronJob, RegisteredIntervalJob, CronMetadata, IntervalMetadata, ScheduleModuleOptions, } from './schedule/index';
+export { HealthModule, HealthCheckService, HealthIndicatorService, HttpHealthIndicator, } from './health/index';
+export type { HealthCheckResult, HealthCheckStatus, HealthIndicatorResult, HealthIndicatorFunction, ResponseCheckCallback, HttpPingOptions, } from './health/index';
+export { ThrottlerModule, ThrottlerGuard, ThrottlerStorage, Throttle, SkipThrottle, THROTTLER_OPTIONS, THROTTLER_STORAGE, THROTTLE_METADATA, SKIP_THROTTLE_METADATA, } from './throttler/index';
+export type { ThrottlerModuleOptions, ThrottleConfig, ThrottlerStore, ThrottlerStorageRecord, RateLimitInfo, } from './throttler/index';
 export { Module } from './module/index';
 export type { ModuleOptions, DynamicModule } from './module/index';
 export { UseMiddleware, UseGuards, UsePipes, UseInterceptors, UseFilters, Catch, SetMetadata, Reflector, APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE, } from './pipeline/index';

package/dist/index.js

@@ -21,6 +21,10 @@ export { CacheModule, CacheService, CacheInterceptor, MemoryCacheStore, CacheKey
 export { EventEmitterModule, EventEmitter, EventEmitterSubscriber, OnEvent, ON_EVENT_METADATA } from "./event-emitter/index.js";
 // Schedule
 export { ScheduleModule, ScheduleRegistry, ScheduleExecutor, Cron, Interval, SCHEDULE_MODULE_OPTIONS, CRON_METADATA, INTERVAL_METADATA } from "./schedule/index.js";
+// Health
+export { HealthModule, HealthCheckService, HealthIndicatorService, HttpHealthIndicator } from "./health/index.js";
+// Throttler
+export { ThrottlerModule, ThrottlerGuard, ThrottlerStorage, Throttle, SkipThrottle, THROTTLER_OPTIONS, THROTTLER_STORAGE, THROTTLE_METADATA, SKIP_THROTTLE_METADATA } from "./throttler/index.js";
 // Module
 export { Module } from "./module/index.js";
 // Pipeline Decorators

package/dist/throttler/index.d.ts

@@ -0,0 +1,6 @@
+export { ThrottlerModule } from './throttler.module';
+export { ThrottlerGuard } from './throttler.guard';
+export { ThrottlerStorage } from './throttler.storage';
+export { Throttle, SkipThrottle } from './throttler.decorators';
+export { THROTTLER_OPTIONS, THROTTLER_STORAGE, THROTTLE_METADATA, SKIP_THROTTLE_METADATA } from './throttler.tokens';
+export type { ThrottlerModuleOptions, ThrottleConfig, ThrottlerStore, ThrottlerStorageRecord, RateLimitInfo } from './throttler.types';

package/dist/throttler/index.js

@@ -0,0 +1,5 @@
+export { ThrottlerModule } from "./throttler.module.js";
+export { ThrottlerGuard } from "./throttler.guard.js";
+export { ThrottlerStorage } from "./throttler.storage.js";
+export { Throttle, SkipThrottle } from "./throttler.decorators.js";
+export { THROTTLER_OPTIONS, THROTTLER_STORAGE, THROTTLE_METADATA, SKIP_THROTTLE_METADATA } from "./throttler.tokens.js";

package/dist/throttler/throttler.decorators.d.ts

@@ -0,0 +1,3 @@
+import type { ThrottleConfig } from './throttler.types';
+export declare const Throttle: (config: ThrottleConfig) => (target: Function | object, propertyKey?: string | symbol) => void;
+export declare const SkipThrottle: () => (target: Function | object, propertyKey?: string | symbol) => void;

package/dist/throttler/throttler.decorators.js

@@ -0,0 +1,4 @@
+import { SetMetadata } from "../pipeline/reflector.js";
+import { THROTTLE_METADATA, SKIP_THROTTLE_METADATA } from "./throttler.tokens.js";
+export const Throttle = (config)=>SetMetadata(THROTTLE_METADATA, config);
+export const SkipThrottle = ()=>SetMetadata(SKIP_THROTTLE_METADATA, true);

package/dist/throttler/throttler.guard.d.ts

@@ -0,0 +1,9 @@
+import type { CanActivate, ExecutionContext } from '../pipeline/types';
+import type { ThrottlerModuleOptions, ThrottlerStore } from './throttler.types';
+export declare class ThrottlerGuard implements CanActivate {
+    private options;
+    private storage;
+    private reflector;
+    constructor(options: ThrottlerModuleOptions, storage: ThrottlerStore);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+}

package/dist/throttler/throttler.guard.js

@@ -0,0 +1,72 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+import { Injectable, Inject } from "../container/decorators.js";
+import { Reflector } from "../pipeline/reflector.js";
+import { TooManyRequestsException } from "../errors/http-exception.js";
+import { THROTTLER_OPTIONS, THROTTLER_STORAGE, THROTTLE_METADATA, SKIP_THROTTLE_METADATA } from "./throttler.tokens.js";
+export class ThrottlerGuard {
+    options;
+    storage;
+    reflector = new Reflector();
+    constructor(options, storage){
+        this.options = options;
+        this.storage = storage;
+    }
+    async canActivate(context) {
+        const skip = this.reflector.getAllAndOverride(SKIP_THROTTLE_METADATA, context);
+        if (skip) {
+            return true;
+        }
+        const override = this.reflector.getAllAndOverride(THROTTLE_METADATA, context);
+        const limit = override?.limit ?? this.options.limit;
+        const ttl = override?.ttl ?? this.options.ttl;
+        const request = context.getRequest();
+        const tracker = this.options.getTracker ? this.options.getTracker(request) : request.headers.get('x-forwarded-for') ?? 'anonymous';
+        const className = context.getClass().name;
+        const handlerName = String(context.getHandler());
+        const key = this.options.generateKey ? this.options.generateKey(tracker, {
+            className,
+            handlerName
+        }) : `throttler:${className}:${handlerName}:${tracker}`;
+        const { count, ttlMs } = await this.storage.increment(key, ttl);
+        const remaining = Math.max(0, limit - count);
+        const resetSeconds = Math.ceil(ttlMs / 1000);
+        const honoContext = context.getContext();
+        honoContext.header('X-RateLimit-Limit', String(limit));
+        honoContext.header('X-RateLimit-Remaining', String(remaining));
+        honoContext.header('X-RateLimit-Reset', String(resetSeconds));
+        const rateLimitInfo = {
+            limit,
+            remaining,
+            reset: resetSeconds
+        };
+        honoContext.set('rateLimit', rateLimitInfo);
+        if (count > limit) {
+            honoContext.header('Retry-After', String(resetSeconds));
+            throw new TooManyRequestsException();
+        }
+        return true;
+    }
+}
+ThrottlerGuard = _ts_decorate([
+    Injectable(),
+    _ts_param(0, Inject(THROTTLER_OPTIONS)),
+    _ts_param(1, Inject(THROTTLER_STORAGE)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof ThrottlerModuleOptions === "undefined" ? Object : ThrottlerModuleOptions,
+        typeof ThrottlerStore === "undefined" ? Object : ThrottlerStore
+    ])
+], ThrottlerGuard);

package/dist/throttler/throttler.module.d.ts

@@ -0,0 +1,5 @@
+import type { DynamicModule } from '../module/types';
+import type { ThrottlerModuleOptions } from './throttler.types';
+export declare class ThrottlerModule {
+    static forRoot(options: ThrottlerModuleOptions): DynamicModule;
+}

package/dist/throttler/throttler.module.js

@@ -0,0 +1,43 @@
+import { METADATA_KEYS } from "../constants.js";
+import { defineMetadata } from "../metadata.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+import { APP_GUARD } from "../pipeline/tokens.js";
+import { ThrottlerGuard } from "./throttler.guard.js";
+import { ThrottlerStorage } from "./throttler.storage.js";
+import { THROTTLER_OPTIONS, THROTTLER_STORAGE } from "./throttler.tokens.js";
+export class ThrottlerModule {
+    static forRoot(options) {
+        const moduleClass = class ThrottlerDynamicModule {
+        };
+        Object.defineProperty(moduleClass, 'name', {
+            value: 'ThrottlerModule'
+        });
+        defineMetadata(METADATA_KEYS.MODULE, true, moduleClass);
+        MetadataRegistry.setModuleOptions(moduleClass, {
+            exports: [
+                THROTTLER_OPTIONS,
+                THROTTLER_STORAGE,
+                ThrottlerGuard
+            ]
+        });
+        const providers = [
+            {
+                token: THROTTLER_OPTIONS,
+                useValue: options
+            },
+            {
+                token: THROTTLER_STORAGE,
+                useValue: options.storage ?? new ThrottlerStorage()
+            },
+            ThrottlerGuard,
+            {
+                token: APP_GUARD,
+                useExisting: ThrottlerGuard
+            }
+        ];
+        return {
+            module: moduleClass,
+            providers
+        };
+    }
+}

package/dist/throttler/throttler.storage.d.ts

@@ -0,0 +1,10 @@
+import type { ThrottlerStore, ThrottlerStorageRecord } from './throttler.types';
+export declare class ThrottlerStorage implements ThrottlerStore {
+    private current;
+    private previous;
+    private lastSwap;
+    private readonly swapIntervalMs;
+    increment(key: string, ttlMs: number): ThrottlerStorageRecord;
+    reset(key: string): void;
+    private maybeSwap;
+}

package/dist/throttler/throttler.storage.js

@@ -0,0 +1,44 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { Injectable } from "../container/decorators.js";
+export class ThrottlerStorage {
+    current = new Map();
+    previous = new Map();
+    lastSwap = Date.now();
+    swapIntervalMs = 60_000;
+    increment(key, ttlMs) {
+        this.maybeSwap();
+        const now = Date.now();
+        let entry = this.current.get(key) ?? this.previous.get(key);
+        if (!entry || now >= entry.resetTime) {
+            entry = {
+                count: 0,
+                resetTime: now + ttlMs
+            };
+        }
+        entry.count++;
+        this.current.set(key, entry);
+        return {
+            count: entry.count,
+            ttlMs: entry.resetTime - now
+        };
+    }
+    reset(key) {
+        this.current.delete(key);
+        this.previous.delete(key);
+    }
+    maybeSwap() {
+        const now = Date.now();
+        if (now - this.lastSwap < this.swapIntervalMs) return;
+        this.previous = this.current;
+        this.current = new Map();
+        this.lastSwap = now;
+    }
+}
+ThrottlerStorage = _ts_decorate([
+    Injectable()
+], ThrottlerStorage);

package/dist/throttler/throttler.tokens.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken } from '../container/types';
+import type { ThrottlerModuleOptions, ThrottlerStore } from './throttler.types';
+export declare const THROTTLER_OPTIONS: InjectionToken<ThrottlerModuleOptions>;
+export declare const THROTTLER_STORAGE: InjectionToken<ThrottlerStore>;
+export declare const THROTTLE_METADATA = "vela:throttle";
+export declare const SKIP_THROTTLE_METADATA = "vela:skip-throttle";

package/dist/throttler/throttler.tokens.js

@@ -0,0 +1,5 @@
+import { InjectionToken } from "../container/types.js";
+export const THROTTLER_OPTIONS = new InjectionToken('THROTTLER_OPTIONS');
+export const THROTTLER_STORAGE = new InjectionToken('THROTTLER_STORAGE');
+export const THROTTLE_METADATA = 'vela:throttle';
+export const SKIP_THROTTLE_METADATA = 'vela:skip-throttle';

package/dist/throttler/throttler.types.d.ts

@@ -0,0 +1,25 @@
+export interface ThrottleConfig {
+    limit: number;
+    ttl: number;
+}
+export interface ThrottlerStorageRecord {
+    count: number;
+    ttlMs: number;
+}
+export interface ThrottlerStore {
+    increment(key: string, ttlMs: number): ThrottlerStorageRecord | Promise<ThrottlerStorageRecord>;
+    reset(key: string): void | Promise<void>;
+}
+export interface RateLimitInfo {
+    limit: number;
+    remaining: number;
+    reset: number;
+}
+export interface ThrottlerModuleOptions extends ThrottleConfig {
+    storage?: ThrottlerStore;
+    getTracker?: (request: Request) => string;
+    generateKey?: (tracker: string, context: {
+        className: string;
+        handlerName: string;
+    }) => string;
+}

package/dist/throttler/throttler.types.js

@@ -0,0 +1 @@
+export { };

package/package.json

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