@velajs/vela 0.1.0 → 0.2.0

package/dist/config/config.module.d.ts

@@ -0,0 +1,5 @@
+import type { DynamicModule } from '../module/types';
+import type { ConfigModuleOptions } from './config.types';
+export declare class ConfigModule {
+    static forRoot<T extends Record<string, unknown>>(options: ConfigModuleOptions<T>): DynamicModule;
+}

package/dist/config/config.module.js

@@ -0,0 +1,32 @@
+import { METADATA_KEYS } from "../constants.js";
+import { defineMetadata } from "../metadata.js";
+import { MetadataRegistry } from "../registry/metadata.registry.js";
+import { ConfigService } from "./config.service.js";
+import { CONFIG_OPTIONS } from "./config.tokens.js";
+export class ConfigModule {
+    static forRoot(options) {
+        const config = options.validate ? options.validate(options.config) : options.config;
+        const moduleClass = class ConfigDynamicModule {
+        };
+        Object.defineProperty(moduleClass, 'name', {
+            value: 'ConfigModule'
+        });
+        defineMetadata(METADATA_KEYS.MODULE, true, moduleClass);
+        MetadataRegistry.setModuleOptions(moduleClass, {
+            exports: [
+                ConfigService,
+                CONFIG_OPTIONS
+            ]
+        });
+        return {
+            module: moduleClass,
+            providers: [
+                {
+                    token: CONFIG_OPTIONS,
+                    useValue: config
+                },
+                ConfigService
+            ]
+        };
+    }
+}

package/dist/config/config.service.d.ts

@@ -0,0 +1,7 @@
+export declare class ConfigService<T extends Record<string, unknown> = Record<string, unknown>> {
+    private readonly config;
+    constructor(config: T);
+    get<V>(key: string): V | undefined;
+    get<V>(key: string, defaultValue: V): V;
+    getAll(): T;
+}

package/dist/config/config.service.js

@@ -0,0 +1,45 @@
+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 } from "../container/decorators.js";
+import { Inject } from "../container/decorators.js";
+import { CONFIG_OPTIONS } from "./config.tokens.js";
+export class ConfigService {
+    config;
+    constructor(config){
+        this.config = config;
+    }
+    get(key, defaultValue) {
+        const parts = key.split('.');
+        let current = this.config;
+        for (const part of parts){
+            if (current === null || current === undefined || typeof current !== 'object') {
+                return defaultValue;
+            }
+            current = current[part];
+        }
+        return current ?? defaultValue;
+    }
+    getAll() {
+        return this.config;
+    }
+}
+ConfigService = _ts_decorate([
+    Injectable(),
+    _ts_param(0, Inject(CONFIG_OPTIONS)),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof T === "undefined" ? Object : T
+    ])
+], ConfigService);

package/dist/config/config.tokens.d.ts

@@ -0,0 +1,2 @@
+import { InjectionToken } from '../container/types';
+export declare const CONFIG_OPTIONS: InjectionToken<Record<string, unknown>>;

package/dist/config/config.tokens.js

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

package/dist/config/config.types.d.ts

@@ -0,0 +1,4 @@
+export interface ConfigModuleOptions<T extends Record<string, unknown> = Record<string, unknown>> {
+    config: T;
+    validate?: (config: T) => T;
+}

package/dist/config/config.types.js

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

package/dist/config/index.d.ts

@@ -0,0 +1,4 @@
+export { ConfigModule } from './config.module';
+export { ConfigService } from './config.service';
+export { CONFIG_OPTIONS } from './config.tokens';
+export type { ConfigModuleOptions } from './config.types';

package/dist/config/index.js

@@ -0,0 +1,3 @@
+export { ConfigModule } from "./config.module.js";
+export { ConfigService } from "./config.service.js";
+export { CONFIG_OPTIONS } from "./config.tokens.js";

package/dist/http/decorators.d.ts

@@ -38,6 +38,7 @@ export declare const Patch: (path?: string) => MethodDecorator;
 export declare const Delete: (path?: string) => MethodDecorator;
 export declare const Options: (path?: string) => MethodDecorator;
 export declare const Head: (path?: string) => MethodDecorator;
+export declare const Sse: (path?: string) => MethodDecorator;
 export declare const Param: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
 export declare const Query: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
 export declare const Body: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;

package/dist/http/decorators.js

@@ -96,6 +96,7 @@ export const Patch = createMethodDecorator(HttpMethod.PATCH);
 export const Delete = createMethodDecorator(HttpMethod.DELETE);
 export const Options = createMethodDecorator(HttpMethod.OPTIONS);
 export const Head = createMethodDecorator(HttpMethod.HEAD);
+export const Sse = createMethodDecorator(HttpMethod.GET);
 // Parameter decorators
 const CUSTOM_PARAM_TYPE = 'custom';
 function createBuiltinParamDecorator(type) {

package/dist/http/index.d.ts

@@ -1,3 +1,3 @@
 export { RouteManager } from './route.manager';
-export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Param, Query, Body, Headers, Req, HttpCode, Header, Redirect, createParamDecorator, isController, } from './decorators';
+export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse, Param, Query, Body, Headers, Req, HttpCode, Header, Redirect, createParamDecorator, isController, } from './decorators';
 export type { RouteMetadata, ControllerMetadata, ControllerOptions, ParamMetadata, ControllerRegistration, } from './types';

package/dist/http/index.js

@@ -1,2 +1,2 @@
 export { RouteManager } from "./route.manager.js";
-export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Param, Query, Body, Headers, Req, HttpCode, Header, Redirect, createParamDecorator, isController } from "./decorators.js";
+export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse, Param, Query, Body, Headers, Req, HttpCode, Header, Redirect, createParamDecorator, isController } from "./decorators.js";

package/dist/index.d.ts

@@ -5,7 +5,11 @@ export { VelaApplication } from './application';
 export { Container, Injectable, Inject, InjectionToken } from './container/index';
 export type { Type, Token, InjectableOptions, ProviderOptions, } from './container/index';
 export { METADATA_KEYS, HttpMethod, ParamType, Scope } from './constants';
-export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Param, Query, Body, Headers, Req, HttpCode, Header, Redirect, createParamDecorator, } from './http/index';
+export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse, Param, Query, Body, Headers, Req, HttpCode, Header, Redirect, createParamDecorator, } from './http/index';
+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 { 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

@@ -8,7 +8,11 @@ export { Container, Injectable, Inject, InjectionToken } from "./container/index
 // Constants
 export { METADATA_KEYS, HttpMethod, ParamType, Scope } from "./constants.js";
 // HTTP Decorators
-export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Param, Query, Body, Headers, Req, HttpCode, Header, Redirect, createParamDecorator } from "./http/index.js";
+export { Controller, Version, Get, Post, Put, Patch, Delete, Options, Head, Sse, Param, Query, Body, Headers, Req, HttpCode, Header, Redirect, createParamDecorator } from "./http/index.js";
+// Services
+export { Logger, LogLevel } from "./services/index.js";
+// Config
+export { ConfigModule, ConfigService, CONFIG_OPTIONS } from "./config/index.js";
 // Module
 export { Module } from "./module/index.js";
 // Pipeline Decorators

package/dist/services/index.d.ts

@@ -0,0 +1,2 @@
+export { Logger, LogLevel } from './logger';
+export type { LoggerService } from './logger';

package/dist/services/index.js

@@ -0,0 +1 @@
+export { Logger, LogLevel } from "./logger.js";

package/dist/services/logger.d.ts

@@ -0,0 +1,30 @@
+export declare enum LogLevel {
+    VERBOSE = 0,
+    DEBUG = 1,
+    LOG = 2,
+    WARN = 3,
+    ERROR = 4,
+    SILENT = 5
+}
+export interface LoggerService {
+    log(message: unknown, ...optionalParams: unknown[]): void;
+    error(message: unknown, ...optionalParams: unknown[]): void;
+    warn(message: unknown, ...optionalParams: unknown[]): void;
+    debug?(message: unknown, ...optionalParams: unknown[]): void;
+    verbose?(message: unknown, ...optionalParams: unknown[]): void;
+}
+export declare class Logger implements LoggerService {
+    static level: LogLevel;
+    private static globalLogger;
+    private context?;
+    static setLogLevel(level: LogLevel): void;
+    static overrideLogger(logger: LoggerService | false): void;
+    constructor(context?: string);
+    setContext(context: string): void;
+    log(message: unknown, ...optionalParams: unknown[]): void;
+    error(message: unknown, ...optionalParams: unknown[]): void;
+    warn(message: unknown, ...optionalParams: unknown[]): void;
+    debug(message: unknown, ...optionalParams: unknown[]): void;
+    verbose(message: unknown, ...optionalParams: unknown[]): void;
+    private formatMessage;
+}

package/dist/services/logger.js

@@ -0,0 +1,95 @@
+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/decorators.js";
+export var LogLevel = /*#__PURE__*/ function(LogLevel) {
+    LogLevel[LogLevel["VERBOSE"] = 0] = "VERBOSE";
+    LogLevel[LogLevel["DEBUG"] = 1] = "DEBUG";
+    LogLevel[LogLevel["LOG"] = 2] = "LOG";
+    LogLevel[LogLevel["WARN"] = 3] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 4] = "ERROR";
+    LogLevel[LogLevel["SILENT"] = 5] = "SILENT";
+    return LogLevel;
+}({});
+export class Logger {
+    static level = 2;
+    static globalLogger;
+    context;
+    static setLogLevel(level) {
+        Logger.level = level;
+    }
+    static overrideLogger(logger) {
+        Logger.globalLogger = logger;
+    }
+    constructor(context){
+        if (context) {
+            this.context = context;
+        }
+    }
+    setContext(context) {
+        this.context = context;
+    }
+    log(message, ...optionalParams) {
+        if (Logger.level > 2) return;
+        if (Logger.globalLogger === false) return;
+        if (Logger.globalLogger) {
+            Logger.globalLogger.log(message, ...optionalParams);
+            return;
+        }
+        console.log(this.formatMessage('LOG', message), ...optionalParams);
+    }
+    error(message, ...optionalParams) {
+        if (Logger.level > 4) return;
+        if (Logger.globalLogger === false) return;
+        if (Logger.globalLogger) {
+            Logger.globalLogger.error(message, ...optionalParams);
+            return;
+        }
+        console.error(this.formatMessage('ERROR', message), ...optionalParams);
+    }
+    warn(message, ...optionalParams) {
+        if (Logger.level > 3) return;
+        if (Logger.globalLogger === false) return;
+        if (Logger.globalLogger) {
+            Logger.globalLogger.warn(message, ...optionalParams);
+            return;
+        }
+        console.warn(this.formatMessage('WARN', message), ...optionalParams);
+    }
+    debug(message, ...optionalParams) {
+        if (Logger.level > 1) return;
+        if (Logger.globalLogger === false) return;
+        if (Logger.globalLogger) {
+            Logger.globalLogger.debug?.(message, ...optionalParams);
+            return;
+        }
+        console.debug(this.formatMessage('DEBUG', message), ...optionalParams);
+    }
+    verbose(message, ...optionalParams) {
+        if (Logger.level > 0) return;
+        if (Logger.globalLogger === false) return;
+        if (Logger.globalLogger) {
+            Logger.globalLogger.verbose?.(message, ...optionalParams);
+            return;
+        }
+        console.debug(this.formatMessage('VERBOSE', message), ...optionalParams);
+    }
+    formatMessage(level, message) {
+        const timestamp = new Date().toISOString();
+        const ctx = this.context ? ` [${this.context}]` : '';
+        return `[Vela] ${timestamp} ${level}${ctx} ${message}`;
+    }
+}
+Logger = _ts_decorate([
+    Injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        String
+    ])
+], Logger);

package/dist/streaming/index.d.ts

@@ -0,0 +1,2 @@
+export { streamSSE, stream, streamText } from 'hono/streaming';
+export type { SSEStreamingApi, SSEMessage } from 'hono/streaming';

package/dist/streaming/index.js

@@ -0,0 +1 @@
+export { streamSSE, stream, streamText } from "hono/streaming";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velajs/vela",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "NestJS-compatible framework for edge runtimes, powered by Hono",
   "type": "module",
   "main": "./dist/index.js",
@@ -9,6 +9,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./streaming": {
+      "types": "./dist/streaming/index.d.ts",
+      "import": "./dist/streaming/index.js"
     }
   },
   "files": [