@velajs/vela 0.2.0 → 0.3.0

package/README.md

@@ -1,13 +1,15 @@
 # @velajs/vela
 
+[![npm version](https://img.shields.io/npm/v/@velajs/vela)](https://www.npmjs.com/package/@velajs/vela)
+[![CI](https://github.com/velajs/vela/actions/workflows/ci.yml/badge.svg)](https://github.com/velajs/vela/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/npm/l/@velajs/vela)](https://github.com/velajs/vela/blob/main/LICENSE)
+
 NestJS-compatible framework for edge runtimes, powered by [Hono](https://hono.dev).
 
 ## Install
 
 ```bash
-npm install @velajs/vela
-# or
-bun add @velajs/vela
+pnpm add @velajs/vela
 ```
 
 ## Quick Start
@@ -74,7 +76,7 @@ No Node.js-specific APIs (`node:fs`, `Buffer`, `process`) are used.
 ## CRUD Module (Optional)
 
 ```bash
-bun add @velajs/crud hono-crud @hono/zod-openapi zod
+pnpm add @velajs/crud hono-crud @hono/zod-openapi zod
 ```
 
 See [`@velajs/crud`](https://github.com/velajs/crud) for documentation.

package/dist/application.d.ts

@@ -1,6 +1,7 @@
 import type { Hono } from 'hono';
 import type { Container } from './container/container';
 import type { Token } from './container/types';
+import type { CorsOptions } from './cors/cors.types';
 import type { RouteManager } from './http/route.manager';
 import type { FilterType, GuardType, InterceptorType, MiddlewareType, PipeType } from './registry/types';
 export declare class VelaApplication {
@@ -36,6 +37,7 @@ export declare class VelaApplication {
     useGlobalGuards(...guards: GuardType[]): this;
     useGlobalInterceptors(...interceptors: InterceptorType[]): this;
     useGlobalFilters(...filters: FilterType[]): this;
+    enableCors(options?: CorsOptions): this;
     get<T>(token: Token<T>): T;
     getHonoApp(): Hono;
     callOnModuleInit(): Promise<void>;

package/dist/application.js

@@ -1,3 +1,4 @@
+import { cors } from "hono/cors";
 import { hasBeforeApplicationShutdown, hasOnApplicationBootstrap, hasOnApplicationShutdown, hasOnModuleDestroy, hasOnModuleInit } from "./lifecycle/index.js";
 export class VelaApplication {
     container;
@@ -68,6 +69,21 @@ export class VelaApplication {
         this.routeManager.useGlobalFilters(...filters);
         return this;
     }
+    enableCors(options = {}) {
+        const corsMiddleware = cors({
+            origin: options.origin ?? '*',
+            allowMethods: options.allowMethods,
+            allowHeaders: options.allowHeaders,
+            exposeHeaders: options.exposeHeaders,
+            credentials: options.credentials,
+            maxAge: options.maxAge
+        });
+        const mw = {
+            use: (c, next)=>corsMiddleware(c, next)
+        };
+        this.routeManager.useGlobalMiddleware(mw);
+        return this;
+    }
     get(token) {
         return this.container.resolve(token);
     }

package/dist/cache/cache.decorators.d.ts

@@ -0,0 +1,2 @@
+export declare const CacheKey: (key: string) => (target: Function | object, propertyKey?: string | symbol) => void;
+export declare const CacheTTL: (seconds: number) => (target: Function | object, propertyKey?: string | symbol) => void;

package/dist/cache/cache.decorators.js

@@ -0,0 +1,4 @@
+import { SetMetadata } from "../pipeline/reflector.js";
+import { CACHE_KEY_METADATA, CACHE_TTL_METADATA } from "./cache.tokens.js";
+export const CacheKey = (key)=>SetMetadata(CACHE_KEY_METADATA, key);
+export const CacheTTL = (seconds)=>SetMetadata(CACHE_TTL_METADATA, seconds);

package/dist/cache/cache.interceptor.d.ts

@@ -0,0 +1,9 @@
+import type { ExecutionContext, CallHandler, NestInterceptor } from '../pipeline/types';
+import type { CacheModuleOptions, CacheStore } from './cache.types';
+export declare class CacheInterceptor implements NestInterceptor {
+    private cacheStore;
+    private options;
+    private reflector;
+    constructor(cacheStore: CacheStore, options: CacheModuleOptions);
+    intercept(context: ExecutionContext, next: CallHandler): Promise<unknown>;
+}

package/dist/cache/cache.interceptor.js

@@ -0,0 +1,60 @@
+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 { CACHE_MANAGER, CACHE_MODULE_OPTIONS, CACHE_KEY_METADATA, CACHE_TTL_METADATA } from "./cache.tokens.js";
+export class CacheInterceptor {
+    cacheStore;
+    options;
+    reflector = new Reflector();
+    constructor(cacheStore, options){
+        this.cacheStore = cacheStore;
+        this.options = options;
+    }
+    async intercept(context, next) {
+        const request = context.getRequest();
+        // Only cache GET requests
+        if (request.method !== 'GET') {
+            return next.handle();
+        }
+        // Determine cache key
+        const customKey = this.reflector.getAllAndOverride(CACHE_KEY_METADATA, context);
+        const url = new URL(request.url);
+        const cacheKey = customKey ?? `cache:GET:${url.pathname}`;
+        // Check cache
+        const cached = this.cacheStore.get(cacheKey);
+        if (cached !== undefined) {
+            return cached;
+        }
+        // Execute handler
+        const result = await next.handle();
+        // Determine TTL
+        const customTtl = this.reflector.getAllAndOverride(CACHE_TTL_METADATA, context);
+        const ttl = customTtl ?? this.options.ttl ?? 5;
+        // Store in cache
+        this.cacheStore.set(cacheKey, result, ttl);
+        return result;
+    }
+}
+CacheInterceptor = _ts_decorate([
+    Injectable(),
+    _ts_param(0, Inject(CACHE_MANAGER)),
+    _ts_param(1, Inject(CACHE_MODULE_OPTIONS)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof CacheStore === "undefined" ? Object : CacheStore,
+        typeof CacheModuleOptions === "undefined" ? Object : CacheModuleOptions
+    ])
+], CacheInterceptor);

package/dist/cache/cache.module.d.ts

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

package/dist/cache/cache.module.js

@@ -0,0 +1,50 @@
+import { METADATA_KEYS } from "../constants.js";
+import { defineMetadata } from "../metadata.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+import { APP_INTERCEPTOR } from "../pipeline/tokens.js";
+import { CacheInterceptor } from "./cache.interceptor.js";
+import { CacheService } from "./cache.service.js";
+import { MemoryCacheStore } from "./cache.store.js";
+import { CACHE_MANAGER, CACHE_MODULE_OPTIONS } from "./cache.tokens.js";
+export class CacheModule {
+    static forRoot(options = {}) {
+        const { ttl = 5, max = 100, isGlobal = false } = options;
+        const store = new MemoryCacheStore(ttl, max);
+        const moduleClass = class CacheDynamicModule {
+        };
+        Object.defineProperty(moduleClass, 'name', {
+            value: 'CacheModule'
+        });
+        defineMetadata(METADATA_KEYS.MODULE, true, moduleClass);
+        MetadataRegistry.setModuleOptions(moduleClass, {
+            exports: [
+                CACHE_MANAGER,
+                CACHE_MODULE_OPTIONS,
+                CacheService,
+                CacheInterceptor
+            ]
+        });
+        const providers = [
+            {
+                token: CACHE_MANAGER,
+                useValue: store
+            },
+            {
+                token: CACHE_MODULE_OPTIONS,
+                useValue: options
+            },
+            CacheService,
+            CacheInterceptor
+        ];
+        if (isGlobal) {
+            providers.push({
+                token: APP_INTERCEPTOR,
+                useExisting: CacheInterceptor
+            });
+        }
+        return {
+            module: moduleClass,
+            providers
+        };
+    }
+}

package/dist/cache/cache.service.d.ts

@@ -0,0 +1,9 @@
+import type { CacheStore } from './cache.types';
+export declare class CacheService {
+    private store;
+    constructor(store: CacheStore);
+    get<T = unknown>(key: string): T | undefined;
+    set<T = unknown>(key: string, value: T, ttl?: number): void;
+    del(key: string): void;
+    clear(): void;
+}

package/dist/cache/cache.service.js

@@ -0,0 +1,42 @@
+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 { CACHE_MANAGER } from "./cache.tokens.js";
+export class CacheService {
+    store;
+    constructor(store){
+        this.store = store;
+    }
+    get(key) {
+        return this.store.get(key);
+    }
+    set(key, value, ttl) {
+        this.store.set(key, value, ttl);
+    }
+    del(key) {
+        this.store.del(key);
+    }
+    clear() {
+        this.store.clear();
+    }
+}
+CacheService = _ts_decorate([
+    Injectable(),
+    _ts_param(0, Inject(CACHE_MANAGER)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof CacheStore === "undefined" ? Object : CacheStore
+    ])
+], CacheService);

package/dist/cache/cache.store.d.ts

@@ -0,0 +1,12 @@
+import type { CacheStore } from './cache.types';
+export declare class MemoryCacheStore implements CacheStore {
+    private store;
+    private defaultTtl;
+    private max;
+    constructor(ttl?: number, max?: number);
+    get<T = unknown>(key: string): T | undefined;
+    set<T = unknown>(key: string, value: T, ttl?: number): void;
+    del(key: string): void;
+    clear(): void;
+    private evict;
+}

package/dist/cache/cache.store.js

@@ -0,0 +1,51 @@
+export class MemoryCacheStore {
+    store = new Map();
+    defaultTtl;
+    max;
+    constructor(ttl = 5, max = 100){
+        this.defaultTtl = ttl;
+        this.max = max;
+    }
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry) return undefined;
+        if (Date.now() > entry.expiresAt) {
+            this.store.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    set(key, value, ttl) {
+        // Evict if at capacity
+        if (!this.store.has(key) && this.store.size >= this.max) {
+            this.evict();
+        }
+        const effectiveTtl = ttl ?? this.defaultTtl;
+        this.store.set(key, {
+            value,
+            expiresAt: Date.now() + effectiveTtl * 1000
+        });
+    }
+    del(key) {
+        this.store.delete(key);
+    }
+    clear() {
+        this.store.clear();
+    }
+    evict() {
+        // First remove expired entries
+        const now = Date.now();
+        for (const [key, entry] of this.store){
+            if (now > entry.expiresAt) {
+                this.store.delete(key);
+            }
+        }
+        // If still at capacity, remove oldest (first inserted)
+        if (this.store.size >= this.max) {
+            const firstKey = this.store.keys().next().value;
+            if (firstKey !== undefined) {
+                this.store.delete(firstKey);
+            }
+        }
+    }
+}

package/dist/cache/cache.tokens.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken } from '../container/types';
+import type { CacheStore, CacheModuleOptions } from './cache.types';
+export declare const CACHE_MANAGER: InjectionToken<CacheStore>;
+export declare const CACHE_MODULE_OPTIONS: InjectionToken<CacheModuleOptions>;
+export declare const CACHE_KEY_METADATA = "vela:cache-key";
+export declare const CACHE_TTL_METADATA = "vela:cache-ttl";

package/dist/cache/cache.tokens.js

@@ -0,0 +1,5 @@
+import { InjectionToken } from "../container/types.js";
+export const CACHE_MANAGER = new InjectionToken('CACHE_MANAGER');
+export const CACHE_MODULE_OPTIONS = new InjectionToken('CACHE_MODULE_OPTIONS');
+export const CACHE_KEY_METADATA = 'vela:cache-key';
+export const CACHE_TTL_METADATA = 'vela:cache-ttl';

package/dist/cache/cache.types.d.ts

@@ -0,0 +1,15 @@
+export interface CacheModuleOptions {
+    ttl?: number;
+    max?: number;
+    isGlobal?: boolean;
+}
+export interface CacheStore {
+    get<T = unknown>(key: string): T | undefined;
+    set<T = unknown>(key: string, value: T, ttl?: number): void;
+    del(key: string): void;
+    clear(): void;
+}
+export interface CacheEntry<T = unknown> {
+    value: T;
+    expiresAt: number;
+}

package/dist/cache/cache.types.js

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

package/dist/cache/index.d.ts

@@ -0,0 +1,7 @@
+export { CacheModule } from './cache.module';
+export { CacheService } from './cache.service';
+export { CacheInterceptor } from './cache.interceptor';
+export { MemoryCacheStore } from './cache.store';
+export { CacheKey, CacheTTL } from './cache.decorators';
+export { CACHE_MANAGER, CACHE_MODULE_OPTIONS, CACHE_KEY_METADATA, CACHE_TTL_METADATA } from './cache.tokens';
+export type { CacheModuleOptions, CacheStore, CacheEntry } from './cache.types';

package/dist/cache/index.js

@@ -0,0 +1,6 @@
+export { CacheModule } from "./cache.module.js";
+export { CacheService } from "./cache.service.js";
+export { CacheInterceptor } from "./cache.interceptor.js";
+export { MemoryCacheStore } from "./cache.store.js";
+export { CacheKey, CacheTTL } from "./cache.decorators.js";
+export { CACHE_MANAGER, CACHE_MODULE_OPTIONS, CACHE_KEY_METADATA, CACHE_TTL_METADATA } from "./cache.tokens.js";

package/dist/cors/cors.module.d.ts

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

package/dist/cors/cors.module.js

@@ -0,0 +1,45 @@
+import { cors } from "hono/cors";
+import { METADATA_KEYS } from "../constants.js";
+import { defineMetadata } from "../metadata.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+import { APP_MIDDLEWARE } from "../pipeline/tokens.js";
+import { CORS_OPTIONS } from "./cors.tokens.js";
+export class CorsModule {
+    static forRoot(options = {}) {
+        const corsMiddleware = cors({
+            origin: options.origin ?? '*',
+            allowMethods: options.allowMethods,
+            allowHeaders: options.allowHeaders,
+            exposeHeaders: options.exposeHeaders,
+            credentials: options.credentials,
+            maxAge: options.maxAge
+        });
+        const middleware = {
+            use: (c, next)=>corsMiddleware(c, next)
+        };
+        const moduleClass = class CorsDynamicModule {
+        };
+        Object.defineProperty(moduleClass, 'name', {
+            value: 'CorsModule'
+        });
+        defineMetadata(METADATA_KEYS.MODULE, true, moduleClass);
+        MetadataRegistry.setModuleOptions(moduleClass, {
+            exports: [
+                CORS_OPTIONS
+            ]
+        });
+        return {
+            module: moduleClass,
+            providers: [
+                {
+                    token: CORS_OPTIONS,
+                    useValue: options
+                },
+                {
+                    token: APP_MIDDLEWARE,
+                    useValue: middleware
+                }
+            ]
+        };
+    }
+}

package/dist/cors/cors.tokens.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '../container/types';
+import type { CorsOptions } from './cors.types';
+export declare const CORS_OPTIONS: InjectionToken<CorsOptions>;

package/dist/cors/cors.tokens.js

@@ -0,0 +1,2 @@
+import { InjectionToken } from "../container/types.js";
+export const CORS_OPTIONS = new InjectionToken('CORS_OPTIONS');

package/dist/cors/cors.types.d.ts

@@ -0,0 +1,8 @@
+export interface CorsOptions {
+    origin?: string | string[] | ((origin: string) => string | undefined | null);
+    allowMethods?: string[];
+    allowHeaders?: string[];
+    exposeHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+}

package/dist/cors/cors.types.js

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

package/dist/cors/index.d.ts

@@ -0,0 +1,3 @@
+export { CorsModule } from './cors.module';
+export { CORS_OPTIONS } from './cors.tokens';
+export type { CorsOptions } from './cors.types';

package/dist/cors/index.js

@@ -0,0 +1,2 @@
+export { CorsModule } from "./cors.module.js";
+export { CORS_OPTIONS } from "./cors.tokens.js";

package/dist/event-emitter/event-emitter.decorators.d.ts

@@ -0,0 +1 @@
+export declare function OnEvent(event: string): MethodDecorator;

package/dist/event-emitter/event-emitter.decorators.js

@@ -0,0 +1,11 @@
+import { ON_EVENT_METADATA } from "./event-emitter.tokens.js";
+export function OnEvent(event) {
+    return (target, propertyKey)=>{
+        const existing = Reflect.getMetadata(ON_EVENT_METADATA, target.constructor) ?? [];
+        existing.push({
+            event,
+            methodName: String(propertyKey)
+        });
+        Reflect.defineMetadata(ON_EVENT_METADATA, existing, target.constructor);
+    };
+}

package/dist/event-emitter/event-emitter.module.d.ts

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

package/dist/event-emitter/event-emitter.module.js

@@ -0,0 +1,22 @@
+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 { EventEmitter } from "./event-emitter.service.js";
+import { EventEmitterSubscriber } from "./event-emitter.subscriber.js";
+export class EventEmitterModule {
+}
+EventEmitterModule = _ts_decorate([
+    Module({
+        providers: [
+            EventEmitter,
+            EventEmitterSubscriber
+        ],
+        exports: [
+            EventEmitter
+        ]
+    })
+], EventEmitterModule);

package/dist/event-emitter/event-emitter.service.d.ts

@@ -0,0 +1,13 @@
+import type { EventHandler } from './event-emitter.types';
+export declare class EventEmitter {
+    private listeners;
+    private onceListeners;
+    on(event: string, handler: EventHandler): this;
+    once(event: string, handler: EventHandler): this;
+    off(event: string, handler: EventHandler): this;
+    emit(event: string, ...args: unknown[]): Promise<void>;
+    removeAllListeners(event?: string): this;
+    listenerCount(event: string): number;
+    private getMatchingHandlers;
+    private matchPattern;
+}

package/dist/event-emitter/event-emitter.service.js

@@ -0,0 +1,92 @@
+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 EventEmitter {
+    listeners = new Map();
+    onceListeners = new Set();
+    on(event, handler) {
+        const handlers = this.listeners.get(event) ?? [];
+        handlers.push(handler);
+        this.listeners.set(event, handlers);
+        return this;
+    }
+    once(event, handler) {
+        this.onceListeners.add(handler);
+        return this.on(event, handler);
+    }
+    off(event, handler) {
+        const handlers = this.listeners.get(event);
+        if (handlers) {
+            const index = handlers.indexOf(handler);
+            if (index !== -1) handlers.splice(index, 1);
+            if (handlers.length === 0) this.listeners.delete(event);
+        }
+        this.onceListeners.delete(handler);
+        return this;
+    }
+    async emit(event, ...args) {
+        const handlers = this.getMatchingHandlers(event);
+        const toRemove = [];
+        await Promise.all(handlers.map(async ({ event: registeredEvent, handler })=>{
+            await handler(...args);
+            if (this.onceListeners.has(handler)) {
+                toRemove.push({
+                    event: registeredEvent,
+                    handler
+                });
+            }
+        }));
+        for (const { event: registeredEvent, handler } of toRemove){
+            this.off(registeredEvent, handler);
+        }
+    }
+    removeAllListeners(event) {
+        if (event) {
+            const handlers = this.listeners.get(event);
+            if (handlers) {
+                for (const h of handlers)this.onceListeners.delete(h);
+            }
+            this.listeners.delete(event);
+        } else {
+            this.listeners.clear();
+            this.onceListeners.clear();
+        }
+        return this;
+    }
+    listenerCount(event) {
+        return this.getMatchingHandlers(event).length;
+    }
+    getMatchingHandlers(event) {
+        const result = [];
+        for (const [pattern, handlers] of this.listeners){
+            if (this.matchPattern(pattern, event)) {
+                for (const handler of handlers){
+                    result.push({
+                        event: pattern,
+                        handler
+                    });
+                }
+            }
+        }
+        return result;
+    }
+    matchPattern(pattern, event) {
+        if (pattern === event) return true;
+        // Convert glob pattern to regex
+        // ** matches any depth (any number of segments)
+        // * matches single segment (no dots)
+        const regexStr = pattern.split('.').map((segment)=>{
+            if (segment === '**') return '.*';
+            if (segment === '*') return '[^.]+';
+            return segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        }).join('\\.');
+        return new RegExp(`^${regexStr}$`).test(event);
+    }
+}
+EventEmitter = _ts_decorate([
+    Injectable()
+], EventEmitter);

package/dist/event-emitter/event-emitter.subscriber.d.ts

@@ -0,0 +1,9 @@
+import { Container } from '../container/container';
+import type { OnApplicationBootstrap } from '../lifecycle/index';
+import { EventEmitter } from './event-emitter.service';
+export declare class EventEmitterSubscriber implements OnApplicationBootstrap {
+    private container;
+    private emitter;
+    constructor(container: Container, emitter: EventEmitter);
+    onApplicationBootstrap(): void;
+}

package/dist/event-emitter/event-emitter.subscriber.js

@@ -0,0 +1,56 @@
+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/index.js";
+import { Container } from "../container/container.js";
+import { EventEmitter } from "./event-emitter.service.js";
+import { ON_EVENT_METADATA } from "./event-emitter.tokens.js";
+export class EventEmitterSubscriber {
+    container;
+    emitter;
+    constructor(container, emitter){
+        this.container = container;
+        this.emitter = emitter;
+    }
+    onApplicationBootstrap() {
+        const tokens = this.container.getTokens();
+        for (const token of tokens){
+            // Skip non-class tokens
+            if (typeof token !== 'function') continue;
+            const metadata = Reflect.getMetadata(ON_EVENT_METADATA, token);
+            if (!metadata || metadata.length === 0) continue;
+            let instance;
+            try {
+                instance = this.container.resolve(token);
+            } catch  {
+                continue;
+            }
+            for (const { event, methodName } of metadata){
+                const method = instance[methodName];
+                if (typeof method === 'function') {
+                    this.emitter.on(event, (...args)=>method.apply(instance, args));
+                }
+            }
+        }
+    }
+}
+EventEmitterSubscriber = _ts_decorate([
+    Injectable(),
+    _ts_param(0, Inject(Container)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Container === "undefined" ? Object : Container,
+        typeof EventEmitter === "undefined" ? Object : EventEmitter
+    ])
+], EventEmitterSubscriber);

package/dist/event-emitter/event-emitter.tokens.d.ts

@@ -0,0 +1 @@
+export declare const ON_EVENT_METADATA = "vela:on-event";

package/dist/event-emitter/event-emitter.tokens.js

@@ -0,0 +1 @@
+export const ON_EVENT_METADATA = 'vela:on-event';

package/dist/event-emitter/event-emitter.types.d.ts

@@ -0,0 +1,5 @@
+export type EventHandler = (...args: unknown[]) => void | Promise<void>;
+export interface OnEventMetadata {
+    event: string;
+    methodName: string;
+}

package/dist/event-emitter/event-emitter.types.js

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

package/dist/event-emitter/index.d.ts

@@ -0,0 +1,6 @@
+export { EventEmitterModule } from './event-emitter.module';
+export { EventEmitter } from './event-emitter.service';
+export { EventEmitterSubscriber } from './event-emitter.subscriber';
+export { OnEvent } from './event-emitter.decorators';
+export { ON_EVENT_METADATA } from './event-emitter.tokens';
+export type { EventHandler, OnEventMetadata } from './event-emitter.types';

package/dist/event-emitter/index.js

@@ -0,0 +1,5 @@
+export { EventEmitterModule } from "./event-emitter.module.js";
+export { EventEmitter } from "./event-emitter.service.js";
+export { EventEmitterSubscriber } from "./event-emitter.subscriber.js";
+export { OnEvent } from "./event-emitter.decorators.js";
+export { ON_EVENT_METADATA } from "./event-emitter.tokens.js";

package/dist/factory.js

@@ -7,6 +7,10 @@ import { APP_GUARD, APP_PIPE, APP_INTERCEPTOR, APP_FILTER, APP_MIDDLEWARE } from
 export const VelaFactory = {
     async create (rootModule) {
         const container = new Container();
+        container.register({
+            token: Container,
+            useValue: container
+        });
         const routeManager = new RouteManager(container);
         ComponentManager.init(container);
         const loader = new ModuleLoader(container, routeManager);

package/dist/index.d.ts

@@ -10,6 +10,14 @@ export { Logger, LogLevel } from './services/index';
 export type { LoggerService } from './services/index';
 export { ConfigModule, ConfigService, CONFIG_OPTIONS } from './config/index';
 export type { ConfigModuleOptions } from './config/index';
+export { CorsModule, CORS_OPTIONS } from './cors/index';
+export type { CorsOptions } from './cors/index';
+export { CacheModule, CacheService, CacheInterceptor, MemoryCacheStore, CacheKey, CacheTTL, CACHE_MANAGER, CACHE_MODULE_OPTIONS, CACHE_KEY_METADATA, CACHE_TTL_METADATA, } from './cache/index';
+export type { CacheModuleOptions, CacheStore, CacheEntry } from './cache/index';
+export { EventEmitterModule, EventEmitter, EventEmitterSubscriber, OnEvent, ON_EVENT_METADATA, } from './event-emitter/index';
+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 { 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

@@ -13,6 +13,14 @@ export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse,
 export { Logger, LogLevel } from "./services/index.js";
 // Config
 export { ConfigModule, ConfigService, CONFIG_OPTIONS } from "./config/index.js";
+// CORS
+export { CorsModule, CORS_OPTIONS } from "./cors/index.js";
+// Cache
+export { CacheModule, CacheService, CacheInterceptor, MemoryCacheStore, CacheKey, CacheTTL, CACHE_MANAGER, CACHE_MODULE_OPTIONS, CACHE_KEY_METADATA, CACHE_TTL_METADATA } from "./cache/index.js";
+// Event Emitter
+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";
 // Module
 export { Module } from "./module/index.js";
 // Pipeline Decorators

package/dist/schedule/index.d.ts

@@ -0,0 +1,7 @@
+export { ScheduleModule } from './schedule.module';
+export { ScheduleRegistry } from './schedule.registry';
+export type { RegisteredCronJob, RegisteredIntervalJob } from './schedule.registry';
+export { ScheduleExecutor } from './schedule.executor';
+export { Cron, Interval } from './schedule.decorators';
+export { SCHEDULE_MODULE_OPTIONS, CRON_METADATA, INTERVAL_METADATA } from './schedule.tokens';
+export type { CronMetadata, IntervalMetadata, ScheduleModuleOptions } from './schedule.types';

package/dist/schedule/index.js

@@ -0,0 +1,5 @@
+export { ScheduleModule } from "./schedule.module.js";
+export { ScheduleRegistry } from "./schedule.registry.js";
+export { ScheduleExecutor } from "./schedule.executor.js";
+export { Cron, Interval } from "./schedule.decorators.js";
+export { SCHEDULE_MODULE_OPTIONS, CRON_METADATA, INTERVAL_METADATA } from "./schedule.tokens.js";

package/dist/schedule/schedule.decorators.d.ts

@@ -0,0 +1,2 @@
+export declare function Cron(expression: string): MethodDecorator;
+export declare function Interval(ms: number): MethodDecorator;

package/dist/schedule/schedule.decorators.js

@@ -0,0 +1,21 @@
+import { CRON_METADATA, INTERVAL_METADATA } from "./schedule.tokens.js";
+export function Cron(expression) {
+    return (target, propertyKey)=>{
+        const existing = Reflect.getMetadata(CRON_METADATA, target.constructor) ?? [];
+        existing.push({
+            expression,
+            methodName: String(propertyKey)
+        });
+        Reflect.defineMetadata(CRON_METADATA, existing, target.constructor);
+    };
+}
+export function Interval(ms) {
+    return (target, propertyKey)=>{
+        const existing = Reflect.getMetadata(INTERVAL_METADATA, target.constructor) ?? [];
+        existing.push({
+            ms,
+            methodName: String(propertyKey)
+        });
+        Reflect.defineMetadata(INTERVAL_METADATA, existing, target.constructor);
+    };
+}

package/dist/schedule/schedule.executor.d.ts

@@ -0,0 +1,11 @@
+import type { OnApplicationBootstrap, OnModuleDestroy } from '../lifecycle/index';
+import { ScheduleRegistry } from './schedule.registry';
+export declare class ScheduleExecutor implements OnApplicationBootstrap, OnModuleDestroy {
+    private registry;
+    private timers;
+    private running;
+    constructor(registry: ScheduleRegistry);
+    onApplicationBootstrap(): void;
+    private scheduleNext;
+    onModuleDestroy(): void;
+}

package/dist/schedule/schedule.executor.js

@@ -0,0 +1,54 @@
+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 { ScheduleRegistry } from "./schedule.registry.js";
+export class ScheduleExecutor {
+    registry;
+    timers = [];
+    running = true;
+    constructor(registry){
+        this.registry = registry;
+    }
+    onApplicationBootstrap() {
+        const jobs = this.registry.getIntervalJobs();
+        for (const job of jobs){
+            this.scheduleNext(job.instance, job.methodName, job.ms);
+        }
+    }
+    scheduleNext(instance, methodName, ms) {
+        if (!this.running) return;
+        const timer = setTimeout(async ()=>{
+            try {
+                const method = instance[methodName];
+                if (typeof method === 'function') {
+                    await method.call(instance);
+                }
+            } catch  {
+            // Swallow errors to keep the loop alive
+            }
+            this.scheduleNext(instance, methodName, ms);
+        }, ms);
+        this.timers.push(timer);
+    }
+    onModuleDestroy() {
+        this.running = false;
+        for (const timer of this.timers){
+            clearTimeout(timer);
+        }
+        this.timers = [];
+    }
+}
+ScheduleExecutor = _ts_decorate([
+    Injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof ScheduleRegistry === "undefined" ? Object : ScheduleRegistry
+    ])
+], ScheduleExecutor);

package/dist/schedule/schedule.module.d.ts

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

package/dist/schedule/schedule.module.js

@@ -0,0 +1,39 @@
+import { METADATA_KEYS } from "../constants.js";
+import { defineMetadata } from "../metadata.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+import { ScheduleExecutor } from "./schedule.executor.js";
+import { ScheduleRegistry } from "./schedule.registry.js";
+import { SCHEDULE_MODULE_OPTIONS } from "./schedule.tokens.js";
+export class ScheduleModule {
+    static forRoot(options = {}) {
+        const { enableTimers = false } = options;
+        const moduleClass = class ScheduleDynamicModule {
+        };
+        Object.defineProperty(moduleClass, 'name', {
+            value: 'ScheduleModule'
+        });
+        defineMetadata(METADATA_KEYS.MODULE, true, moduleClass);
+        const providers = [
+            {
+                token: SCHEDULE_MODULE_OPTIONS,
+                useValue: options
+            },
+            ScheduleRegistry
+        ];
+        const exports = [
+            SCHEDULE_MODULE_OPTIONS,
+            ScheduleRegistry
+        ];
+        if (enableTimers) {
+            providers.push(ScheduleExecutor);
+            exports.push(ScheduleExecutor);
+        }
+        MetadataRegistry.setModuleOptions(moduleClass, {
+            exports
+        });
+        return {
+            module: moduleClass,
+            providers
+        };
+    }
+}

package/dist/schedule/schedule.registry.d.ts

@@ -0,0 +1,23 @@
+import { Container } from '../container/container';
+import type { OnApplicationBootstrap } from '../lifecycle/index';
+export interface RegisteredCronJob {
+    expression: string;
+    methodName: string;
+    instance: unknown;
+    target: Function;
+}
+export interface RegisteredIntervalJob {
+    ms: number;
+    methodName: string;
+    instance: unknown;
+    target: Function;
+}
+export declare class ScheduleRegistry implements OnApplicationBootstrap {
+    private container;
+    private cronJobs;
+    private intervalJobs;
+    constructor(container: Container);
+    onApplicationBootstrap(): void;
+    getCronJobs(): RegisteredCronJob[];
+    getIntervalJobs(): RegisteredIntervalJob[];
+}

package/dist/schedule/schedule.registry.js

@@ -0,0 +1,78 @@
+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/index.js";
+import { Container } from "../container/container.js";
+import { CRON_METADATA, INTERVAL_METADATA } from "./schedule.tokens.js";
+export class ScheduleRegistry {
+    container;
+    cronJobs = [];
+    intervalJobs = [];
+    constructor(container){
+        this.container = container;
+    }
+    onApplicationBootstrap() {
+        const tokens = this.container.getTokens();
+        for (const token of tokens){
+            if (typeof token !== 'function') continue;
+            const cronMeta = Reflect.getMetadata(CRON_METADATA, token);
+            const intervalMeta = Reflect.getMetadata(INTERVAL_METADATA, token);
+            if (!cronMeta && !intervalMeta) continue;
+            let instance;
+            try {
+                instance = this.container.resolve(token);
+            } catch  {
+                continue;
+            }
+            if (cronMeta) {
+                for (const { expression, methodName } of cronMeta){
+                    this.cronJobs.push({
+                        expression,
+                        methodName,
+                        instance,
+                        target: token
+                    });
+                }
+            }
+            if (intervalMeta) {
+                for (const { ms, methodName } of intervalMeta){
+                    this.intervalJobs.push({
+                        ms,
+                        methodName,
+                        instance,
+                        target: token
+                    });
+                }
+            }
+        }
+    }
+    getCronJobs() {
+        return [
+            ...this.cronJobs
+        ];
+    }
+    getIntervalJobs() {
+        return [
+            ...this.intervalJobs
+        ];
+    }
+}
+ScheduleRegistry = _ts_decorate([
+    Injectable(),
+    _ts_param(0, Inject(Container)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Container === "undefined" ? Object : Container
+    ])
+], ScheduleRegistry);

package/dist/schedule/schedule.tokens.d.ts

@@ -0,0 +1,5 @@
+import { InjectionToken } from '../container/types';
+import type { ScheduleModuleOptions } from './schedule.types';
+export declare const SCHEDULE_MODULE_OPTIONS: InjectionToken<ScheduleModuleOptions>;
+export declare const CRON_METADATA = "vela:cron";
+export declare const INTERVAL_METADATA = "vela:interval";

package/dist/schedule/schedule.tokens.js

@@ -0,0 +1,4 @@
+import { InjectionToken } from "../container/types.js";
+export const SCHEDULE_MODULE_OPTIONS = new InjectionToken('SCHEDULE_MODULE_OPTIONS');
+export const CRON_METADATA = 'vela:cron';
+export const INTERVAL_METADATA = 'vela:interval';

package/dist/schedule/schedule.types.d.ts

@@ -0,0 +1,11 @@
+export interface CronMetadata {
+    expression: string;
+    methodName: string;
+}
+export interface IntervalMetadata {
+    ms: number;
+    methodName: string;
+}
+export interface ScheduleModuleOptions {
+    enableTimers?: boolean;
+}

package/dist/schedule/schedule.types.js

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

package/package.json

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