@gravito/echo 3.1.1 → 4.0.0

package/dist/core/src/Container.d.ts

@@ -1,153 +0,0 @@
-import type { RequestScopeManager } from './Container/RequestScopeManager';
-/**
- * Factory type for creating service instances
- */
-export type Factory<T> = (container: Container) => T;
-/**
- * ServiceMap interface for type-safe IoC resolution.
- *
- * Extend this interface via module augmentation to get type inference:
- * @example
- * ```typescript
- * declare module '@gravito/core' {
- *   interface ServiceMap {
- *     logger: Logger
- *     db: DatabaseConnection
- *   }
- * }
- * ```
- */
-export type ServiceMap = {};
-/**
- * ServiceKey represents the allowed keys for service resolution.
- * Includes keys from ServiceMap, generic strings, or symbols.
- */
-export type ServiceKey = keyof ServiceMap | (string & {}) | symbol;
-/**
- * Container - Simple Dependency Injection Container.
- * Manages service bindings and singleton instances.
- * @public
- */
-export declare class Container {
-    private bindings;
-    private instances;
-    private resolutionStack;
-    /**
-     * Run a function within a request scope context.
-     *
-     * All service resolutions within the function will use the provided scope,
-     * enabling request-scoped service instances to be properly isolated.
-     *
-     * @template T - The return type of the function.
-     * @param scope - The RequestScopeManager for this request.
-     * @param fn - The function to execute within the scope.
-     * @returns The result of the function.
-     *
-     * @example
-     * ```typescript
-     * const scope = new RequestScopeManager()
-     * const result = await Container.runWithScope(scope, async () => {
-     *   const service = container.make('requestScoped')
-     *   return service.doSomething()
-     * })
-     * ```
-     */
-    static runWithScope<T>(scope: RequestScopeManager, fn: () => T | Promise<T>): T | Promise<T>;
-    /**
-     * Bind a service to the container.
-     *
-     * A new instance will be created by the factory function every time the
-     * service is resolved from the container.
-     *
-     * @template T - The type of the service being bound.
-     * @param key - The unique identifier for the service.
-     * @param factory - The factory function that creates the service instance.
-     *
-     * @example
-     * ```typescript
-     * container.bind('logger', (c) => new ConsoleLogger());
-     * ```
-     */
-    bind<T>(key: ServiceKey, factory: Factory<T>): void;
-    /**
-     * Bind a shared service to the container (Singleton).
-     *
-     * The factory function will be called only once, and the same instance
-     * will be returned on every subsequent resolution.
-     *
-     * @template T - The type of the service being bound.
-     * @param key - The unique identifier for the service.
-     * @param factory - The factory function that creates the service instance.
-     *
-     * @example
-     * ```typescript
-     * container.singleton('db', (c) => new DatabaseConnection());
-     * ```
-     */
-    singleton<T>(key: ServiceKey, factory: Factory<T>): void;
-    /**
-     * Bind a request-scoped service to the container.
-     *
-     * A new instance will be created for each request and cached within that request.
-     * The service is automatically cleaned up when the request ends.
-     *
-     * @template T - The type of the service being bound.
-     * @param key - The unique identifier for the service.
-     * @param factory - The factory function that creates the service instance.
-     *
-     * @example
-     * ```typescript
-     * container.scoped('requestCache', (c) => new RequestProductCache());
-     * ```
-     */
-    scoped<T>(key: ServiceKey, factory: Factory<T>): void;
-    /**
-     * Register an existing instance as a shared service.
-     *
-     * @param key - The unique identifier for the service.
-     * @param instance - The instance to register.
-     */
-    instance<T>(key: ServiceKey, instance: T): void;
-    /**
-     * Check if a service is request-scoped.
-     *
-     * @param key - The service key to check.
-     * @returns True if the service is request-scoped.
-     */
-    isRequestScoped(key: ServiceKey): boolean;
-    /**
-     * Resolve a service instance from the container.
-     *
-     * Automatically handles singleton caching and factory execution.
-     *
-     * @template T - The expected type of the service.
-     * @param key - The unique identifier for the service.
-     * @returns The resolved service instance.
-     * @throws Error if the service key is not found in the container.
-     *
-     * @example
-     * ```typescript
-     * const logger = container.make<Logger>('logger');
-     * ```
-     */
-    make<K extends keyof ServiceMap>(key: K): ServiceMap[K];
-    make<T>(key: ServiceKey): T;
-    /**
-     * Check if a service is bound or has an instance in the container.
-     *
-     * @param key - The service key to check.
-     * @returns True if the service exists.
-     */
-    has(key: ServiceKey): boolean;
-    /**
-     * Flush all instances and bindings from the container.
-     * Resets the container to an empty state.
-     */
-    flush(): void;
-    /**
-     * Forget a specific instance while keeping its binding.
-     *
-     * @param key - The service key to forget.
-     */
-    forget(key: ServiceKey): void;
-}

package/dist/core/src/ErrorHandler.d.ts

@@ -1,66 +0,0 @@
-/**
- * @fileoverview ErrorHandler - Centralized Error Handling for Gravito Framework
- *
- * Extracted from PlanetCore to follow Single Responsibility Principle.
- * Handles HTTP errors, validation errors, and error rendering.
- *
- * @module @gravito/core
- * @since 1.3.0
- */
-import type { HookManager } from './HookManager';
-import type { GravitoContext } from './http/types';
-import type { Logger } from './Logger';
-/**
- * HTTP Status Code to Error Code mapping
- */
-export declare function codeFromStatus(status: number): string;
-/**
- * HTTP Status Code to Message mapping
- */
-export declare function messageFromStatus(status: number): string;
-/**
- * Dependencies injected into ErrorHandler
- * @public
- */
-export interface ErrorHandlerDeps {
-    logger: Logger;
-    hooks: HookManager;
-    getCore: () => unknown;
-}
-/**
- * ErrorHandler - Centralized error handling logic
- *
- * @example
- * ```typescript
- * const handler = new ErrorHandler({ logger, hooks, getCore: () => core })
- * adapter.onError(handler.handleError.bind(handler))
- * adapter.onNotFound(handler.handleNotFound.bind(handler))
- * ```
- */
-export declare class ErrorHandler {
-    private deps;
-    constructor(deps: ErrorHandlerDeps);
-    /**
-     * Handle application errors
-     *
-     * Integrates RequestScope cleanup to ensure proper resource management
-     * even when errors occur during request processing.
-     */
-    handleError(err: unknown, c: GravitoContext): Promise<Response>;
-    /**
-     * Handle 404 Not Found errors
-     */
-    handleNotFound(c: GravitoContext): Promise<Response>;
-    /**
-     * Handle validation error redirect for HTML requests
-     */
-    private handleValidationRedirect;
-    /**
-     * Log error based on context settings
-     */
-    private logError;
-    /**
-     * Render error response (HTML or JSON)
-     */
-    private renderErrorResponse;
-}

package/dist/core/src/Event.d.ts

@@ -1,5 +0,0 @@
-/**
- * Event base class and related types.
- */
-export type { Channel, ShouldBroadcast } from './types/events';
-export { Event } from './types/events';

package/dist/core/src/EventManager.d.ts

@@ -1,123 +0,0 @@
-import { Event } from './Event';
-import type { Listener } from './Listener';
-import type { PlanetCore } from './PlanetCore';
-/**
- * Listener registration metadata.
- */
-interface ListenerRegistration<TEvent extends Event = Event> {
-    listener: Listener<TEvent> | (new () => Listener<TEvent>);
-    queue?: string;
-    connection?: string;
-    delay?: number;
-}
-/**
- * Event manager.
- *
- * Provides type-safe event dispatching and listener registration.
- * Supports both synchronous listeners and asynchronous (queued) listeners.
- *
- * @example
- * ```typescript
- * class UserRegistered extends Event {
- *   constructor(public user: User) {
- *     super()
- *   }
- * }
- *
- * class SendWelcomeEmail implements Listener<UserRegistered> {
- *   async handle(event: UserRegistered): Promise<void> {
- *     // send welcome email
- *   }
- * }
- *
- * // Register listener
- * core.events.listen(UserRegistered, SendWelcomeEmail)
- *
- * // Dispatch event
- * await core.events.dispatch(new UserRegistered(user))
- * ```
- */
-export declare class EventManager {
-    private core;
-    /**
-     * Listener registry.
-     * Key: event class or event name
-     * Value: listener registrations
-     */
-    private listeners;
-    /**
-     * Broadcast manager (optional, injected by `orbit-broadcasting`).
-     */
-    private broadcastManager;
-    /**
-     * Queue manager (optional, injected by `orbit-queue`).
-     */
-    private queueManager;
-    constructor(core: PlanetCore);
-    /**
-     * Register the broadcast manager (called by `orbit-broadcasting`).
-     */
-    setBroadcastManager(manager: EventManager['broadcastManager']): void;
-    /**
-     * Register the queue manager (called by `orbit-queue`).
-     */
-    setQueueManager(manager: EventManager['queueManager']): void;
-    /**
-     * Register an event listener.
-     *
-     * @param event - Event class or event name
-     * @param listener - Listener instance or listener class
-     * @param options - Optional queue options
-     *
-     * @example
-     * ```typescript
-     * // Synchronous listener
-     * core.events.listen(UserRegistered, SendWelcomeEmail)
-     *
-     * // Queued listener (async)
-     * core.events.listen(UserRegistered, SendWelcomeEmail, {
-     *   queue: 'emails',
-     *   delay: 60
-     * })
-     * ```
-     */
-    listen<TEvent extends Event>(event: string | (new (...args: unknown[]) => TEvent), listener: Listener<TEvent> | (new () => Listener<TEvent>), options?: {
-        queue?: string;
-        connection?: string;
-        delay?: number;
-    }): void;
-    /**
-     * Remove an event listener.
-     *
-     * @param event - Event class or event name
-     * @param listener - Listener to remove
-     */
-    unlisten<TEvent extends Event>(event: string | (new (...args: unknown[]) => TEvent), listener: Listener<TEvent> | (new () => Listener<TEvent>)): void;
-    /**
-     * Dispatch an event.
-     *
-     * Runs all registered listeners. If a listener implements `ShouldQueue` or
-     * has queue options, the listener will be pushed to the queue for async execution.
-     *
-     * @param event - Event instance
-     *
-     * @example
-     * ```typescript
-     * await core.events.dispatch(new UserRegistered(user))
-     * ```
-     */
-    dispatch<TEvent extends Event>(event: TEvent): Promise<void>;
-    /**
-     * Serialize an event (for queueing).
-     */
-    private serializeEvent;
-    /**
-     * Get all registered listeners.
-     */
-    getListeners(event?: string | (new () => Event)): ListenerRegistration[];
-    /**
-     * Clear all listeners.
-     */
-    clear(): void;
-}
-export {};

package/dist/core/src/GlobalErrorHandlers.d.ts

@@ -1,47 +0,0 @@
-import type { Logger } from './Logger';
-import type { PlanetCore } from './PlanetCore';
-/**
- * Type of process-level error
- * @public
- */
-export type GlobalProcessErrorKind = 'unhandledRejection' | 'uncaughtException';
-/**
- * Context payload for global error handler filters/actions
- * @public
- */
-export type GlobalProcessErrorHandlerContext = {
-    core?: PlanetCore;
-    kind: GlobalProcessErrorKind;
-    error: unknown;
-    isProduction: boolean;
-    timestamp: number;
-    logLevel?: 'error' | 'warn' | 'info' | 'none';
-    logMessage?: string;
-    exit?: boolean;
-    exitCode?: number;
-    gracePeriodMs?: number;
-};
-/**
- * Error handling strategy
- * @public
- */
-export type GlobalErrorHandlersMode = 'log' | 'exit' | 'exitInProduction';
-/**
- * Options for registering global handlers
- * @public
- */
-export type RegisterGlobalErrorHandlersOptions = {
-    core?: PlanetCore;
-    logger?: Logger;
-    mode?: GlobalErrorHandlersMode;
-    exitCode?: number;
-    gracePeriodMs?: number;
-};
-/**
- * Register process-level error handlers (`unhandledRejection` / `uncaughtException`).
- *
- * - `mode: "log"`: only log/report
- * - `mode: "exit"`: report then `process.exit(exitCode)`
- * - `mode: "exitInProduction"`: exit only when `NODE_ENV=production` (default)
- */
-export declare function registerGlobalErrorHandlers(options?: RegisterGlobalErrorHandlersOptions): () => void;

package/dist/core/src/GravitoServer.d.ts

@@ -1,28 +0,0 @@
-import { type GravitoConfig, PlanetCore } from './PlanetCore';
-/**
- * Manifest describing a Gravito application structure.
- * @public
- */
-export interface GravitoManifest {
-    name: string;
-    version?: string;
-    modules: string[];
-    config?: GravitoConfig;
-}
-/**
- * Function type for asynchronous module resolution.
- * @public
- */
-export type ModuleResolver = () => Promise<any>;
-/**
- * Gravito 核心啟動引擎 (已解耦)
- */
-export declare class GravitoServer {
-    /**
-     * 一鍵建立並組裝伺服器
-     * @param manifest 站點描述清單
-     * @param resolvers 模組解析器字典
-     * @param baseOrbits 基礎軌道模組 (例如 OrbitMonolith)
-     */
-    static create(manifest: GravitoManifest, resolvers: Record<string, ModuleResolver>, baseOrbits?: any[]): Promise<PlanetCore>;
-}