@objectstack/runtime 4.0.3 → 4.0.5

package/src/http-server.ts

@@ -1,142 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import { IHttpServer, RouteHandler, Middleware } from '@objectstack/core';
-
-/**
- * HttpServer - Unified HTTP Server Abstraction
- * 
- * Provides a framework-agnostic HTTP server interface that wraps
- * underlying server implementations (Hono, Express, Fastify, etc.)
- * 
- * This class serves as an adapter between the IHttpServer interface
- * and concrete server implementations, allowing plugins to register
- * routes and middleware without depending on specific frameworks.
- * 
- * Features:
- * - Unified route registration API
- * - Middleware management with ordering
- * - Request/response lifecycle hooks
- * - Framework-agnostic abstractions
- */
-export class HttpServer implements IHttpServer {
-    protected server: IHttpServer;
-    protected routes: Map<string, RouteHandler>;
-    protected middlewares: Middleware[];
-    
-    /**
-     * Create an HTTP server wrapper
-     * @param server - The underlying server implementation (Hono, Express, etc.)
-     */
-    constructor(server: IHttpServer) {
-        this.server = server;
-        this.routes = new Map();
-        this.middlewares = [];
-    }
-    
-    /**
-     * Register a GET route handler
-     * @param path - Route path (e.g., '/api/users/:id')
-     * @param handler - Route handler function
-     */
-    get(path: string, handler: RouteHandler): void {
-        const key = `GET:${path}`;
-        this.routes.set(key, handler);
-        this.server.get(path, handler);
-    }
-    
-    /**
-     * Register a POST route handler
-     * @param path - Route path
-     * @param handler - Route handler function
-     */
-    post(path: string, handler: RouteHandler): void {
-        const key = `POST:${path}`;
-        this.routes.set(key, handler);
-        this.server.post(path, handler);
-    }
-    
-    /**
-     * Register a PUT route handler
-     * @param path - Route path
-     * @param handler - Route handler function
-     */
-    put(path: string, handler: RouteHandler): void {
-        const key = `PUT:${path}`;
-        this.routes.set(key, handler);
-        this.server.put(path, handler);
-    }
-    
-    /**
-     * Register a DELETE route handler
-     * @param path - Route path
-     * @param handler - Route handler function
-     */
-    delete(path: string, handler: RouteHandler): void {
-        const key = `DELETE:${path}`;
-        this.routes.set(key, handler);
-        this.server.delete(path, handler);
-    }
-    
-    /**
-     * Register a PATCH route handler
-     * @param path - Route path
-     * @param handler - Route handler function
-     */
-    patch(path: string, handler: RouteHandler): void {
-        const key = `PATCH:${path}`;
-        this.routes.set(key, handler);
-        this.server.patch(path, handler);
-    }
-    
-    /**
-     * Register middleware
-     * @param path - Optional path to apply middleware to (if omitted, applies globally)
-     * @param handler - Middleware function
-     */
-    use(path: string | Middleware, handler?: Middleware): void {
-        if (typeof path === 'function') {
-            // Global middleware
-            this.middlewares.push(path);
-            this.server.use(path);
-        } else if (handler) {
-            // Path-specific middleware
-            this.middlewares.push(handler);
-            this.server.use(path, handler);
-        }
-    }
-    
-    /**
-     * Start the HTTP server
-     * @param port - Port number to listen on
-     * @returns Promise that resolves when server is ready
-     */
-    async listen(port: number): Promise<void> {
-        await this.server.listen(port);
-    }
-    
-    /**
-     * Stop the HTTP server
-     * @returns Promise that resolves when server is stopped
-     */
-    async close(): Promise<void> {
-        if (this.server.close) {
-            await this.server.close();
-        }
-    }
-    
-    /**
-     * Get registered routes
-     * @returns Map of route keys to handlers
-     */
-    getRoutes(): Map<string, RouteHandler> {
-        return new Map(this.routes);
-    }
-    
-    /**
-     * Get registered middlewares
-     * @returns Array of middleware functions
-     */
-    getMiddlewares(): Middleware[] {
-        return [...this.middlewares];
-    }
-}

package/src/index.ts

@@ -1,39 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-// Export Kernels
-export { ObjectKernel } from '@objectstack/core';
-
-// Export Runtime
-export { Runtime } from './runtime.js';
-export type { RuntimeConfig } from './runtime.js';
-
-// Export Plugins
-export { DriverPlugin } from './driver-plugin.js';
-export { AppPlugin } from './app-plugin.js';
-export { SeedLoaderService } from './seed-loader.js';
-export { createDispatcherPlugin } from './dispatcher-plugin.js';
-export type { DispatcherPluginConfig } from './dispatcher-plugin.js';
-
-// Export HTTP Server Components
-export { HttpServer } from './http-server.js';
-export { HttpDispatcher } from './http-dispatcher.js';
-export type { HttpProtocolContext, HttpDispatcherResult } from './http-dispatcher.js';
-export { MiddlewareManager } from './middleware.js';
-
-// Re-export from @objectstack/rest
-export {
-    RestServer,
-    RouteManager,
-    RouteGroupBuilder,
-    createRestApiPlugin,
-} from '@objectstack/rest';
-export type {
-    RouteEntry,
-    RestApiPluginConfig,
-} from '@objectstack/rest';
-
-// Export Types
-export * from '@objectstack/core';
-
-
-

package/src/middleware.ts

@@ -1,222 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import { Middleware, IHttpRequest, IHttpResponse } from '@objectstack/core';
-import { MiddlewareConfig, MiddlewareType } from '@objectstack/spec/system';
-
-/**
- * Middleware Entry
- * Internal representation of registered middleware
- */
-interface MiddlewareEntry {
-    name: string;
-    type: MiddlewareType;
-    middleware: Middleware;
-    order: number;
-    enabled: boolean;
-    paths?: {
-        include?: string[];
-        exclude?: string[];
-    };
-}
-
-/**
- * MiddlewareManager
- * 
- * Manages middleware registration, ordering, and execution.
- * Provides fine-grained control over middleware chains with:
- * - Execution order management
- * - Path-based filtering
- * - Enable/disable individual middleware
- * - Middleware categorization by type
- * 
- * @example
- * const manager = new MiddlewareManager();
- * 
- * // Register middleware with configuration
- * manager.register({
- *   name: 'auth',
- *   type: 'authentication',
- *   order: 10,
- *   paths: { exclude: ['/health', '/metrics'] }
- * }, authMiddleware);
- * 
- * // Get sorted middleware chain
- * const chain = manager.getMiddlewareChain();
- * chain.forEach(mw => server.use(mw));
- */
-export class MiddlewareManager {
-    private middlewares: Map<string, MiddlewareEntry>;
-    
-    constructor() {
-        this.middlewares = new Map();
-    }
-    
-    /**
-     * Register middleware with configuration
-     * @param config - Middleware configuration
-     * @param middleware - Middleware function
-     */
-    register(config: MiddlewareConfig, middleware: Middleware): void {
-        const entry: MiddlewareEntry = {
-            name: config.name,
-            type: config.type,
-            middleware,
-            order: config.order ?? 100,
-            enabled: config.enabled ?? true,
-            paths: config.paths,
-        };
-        
-        this.middlewares.set(config.name, entry);
-    }
-    
-    /**
-     * Unregister middleware by name
-     * @param name - Middleware name
-     */
-    unregister(name: string): void {
-        this.middlewares.delete(name);
-    }
-    
-    /**
-     * Enable middleware by name
-     * @param name - Middleware name
-     */
-    enable(name: string): void {
-        const entry = this.middlewares.get(name);
-        if (entry) {
-            entry.enabled = true;
-        }
-    }
-    
-    /**
-     * Disable middleware by name
-     * @param name - Middleware name
-     */
-    disable(name: string): void {
-        const entry = this.middlewares.get(name);
-        if (entry) {
-            entry.enabled = false;
-        }
-    }
-    
-    /**
-     * Get middleware entry by name
-     * @param name - Middleware name
-     */
-    get(name: string): MiddlewareEntry | undefined {
-        return this.middlewares.get(name);
-    }
-    
-    /**
-     * Get all middleware entries
-     */
-    getAll(): MiddlewareEntry[] {
-        return Array.from(this.middlewares.values());
-    }
-    
-    /**
-     * Get middleware by type
-     * @param type - Middleware type
-     */
-    getByType(type: MiddlewareType): MiddlewareEntry[] {
-        return this.getAll().filter(entry => entry.type === type);
-    }
-    
-    /**
-     * Get middleware chain sorted by order
-     * Returns only enabled middleware
-     */
-    getMiddlewareChain(): Middleware[] {
-        return this.getAll()
-            .filter(entry => entry.enabled)
-            .sort((a, b) => a.order - b.order)
-            .map(entry => entry.middleware);
-    }
-    
-    /**
-     * Get middleware chain with path filtering
-     * @param path - Request path to match against
-     */
-    getMiddlewareChainForPath(path: string): Middleware[] {
-        return this.getAll()
-            .filter(entry => {
-                if (!entry.enabled) return false;
-                
-                // Check path filters
-                if (entry.paths) {
-                    // Check exclude patterns
-                    if (entry.paths.exclude) {
-                        const excluded = entry.paths.exclude.some(pattern => 
-                            this.matchPath(path, pattern)
-                        );
-                        if (excluded) return false;
-                    }
-                    
-                    // Check include patterns (if specified)
-                    if (entry.paths.include) {
-                        const included = entry.paths.include.some(pattern => 
-                            this.matchPath(path, pattern)
-                        );
-                        if (!included) return false;
-                    }
-                }
-                
-                return true;
-            })
-            .sort((a, b) => a.order - b.order)
-            .map(entry => entry.middleware);
-    }
-    
-    /**
-     * Match path against pattern (simple glob matching)
-     * @param path - Request path
-     * @param pattern - Pattern to match (supports * wildcard)
-     */
-    private matchPath(path: string, pattern: string): boolean {
-        // Convert glob pattern to regex
-        const regexPattern = pattern
-            .replace(/\*/g, '.*')
-            .replace(/\?/g, '.');
-        
-        const regex = new RegExp(`^${regexPattern}$`);
-        return regex.test(path);
-    }
-    
-    /**
-     * Clear all middleware
-     */
-    clear(): void {
-        this.middlewares.clear();
-    }
-    
-    /**
-     * Get middleware count
-     */
-    count(): number {
-        return this.middlewares.size;
-    }
-    
-    /**
-     * Create a composite middleware from the chain
-     * This can be used to apply all middleware at once
-     */
-    createCompositeMiddleware(): Middleware {
-        const chain = this.getMiddlewareChain();
-        
-        return async (req: IHttpRequest, res: IHttpResponse, next: () => void | Promise<void>) => {
-            let index = 0;
-            
-            const executeNext = async (): Promise<void> => {
-                if (index >= chain.length) {
-                    await next();
-                    return;
-                }
-                
-                const middleware = chain[index++];
-                await middleware(req, res, executeNext);
-            };
-            
-            await executeNext();
-        };
-    }
-}

package/src/runtime.test.ts

@@ -1,65 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { Runtime } from './runtime';
-import { IHttpServer, PluginContext } from '@objectstack/core';
-
-// Mock ObjectKernel to isolate Runtime logic
-vi.mock('@objectstack/core', async () => {
-    const actual = await vi.importActual<any>('@objectstack/core');
-    return {
-        ...actual,
-        ObjectKernel: class {
-            use = vi.fn();
-            registerService = vi.fn();
-            bootstrap = vi.fn().mockResolvedValue(undefined);
-            getServices = vi.fn().mockReturnValue(new Map());
-        }
-    };
-});
-
-describe('Runtime', () => {
-    it('should initialize successfully', () => {
-        const runtime = new Runtime();
-        expect(runtime).toBeDefined();
-        // Should create a kernel
-        expect(runtime.getKernel()).toBeDefined();
-    });
-
-    it('should not auto-register any plugins', () => {
-        const runtime = new Runtime();
-        const kernel = runtime.getKernel();
-        // Runtime is a clean slate — no plugins auto-registered
-        expect(kernel.use).not.toHaveBeenCalled();
-    });
-
-    it('should register external http server if provided', () => {
-        const mockServer: IHttpServer = {
-            listen: vi.fn(),
-            close: vi.fn(),
-            get: vi.fn(),
-            post: vi.fn(),
-            put: vi.fn(),
-            delete: vi.fn(),
-            patch: vi.fn(),
-            use: vi.fn(),
-        };
-        
-        const runtime = new Runtime({ server: mockServer });
-        const kernel = runtime.getKernel();
-        
-        expect(kernel.registerService).toHaveBeenCalledWith('http.server', mockServer);
-    });
-
-    it('should delegate use() to kernel', () => {
-        const runtime = new Runtime();
-        const mockPlugin = { name: 'test', init: vi.fn() };
-        
-        runtime.use(mockPlugin);
-        expect(runtime.getKernel().use).toHaveBeenCalledWith(mockPlugin);
-    });
-
-    it('should delegate start() to kernel.bootstrap()', async () => {
-        const runtime = new Runtime();
-        await runtime.start();
-        expect(runtime.getKernel().bootstrap).toHaveBeenCalled();
-    });
-});

package/src/runtime.ts

@@ -1,69 +0,0 @@
-// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
-
-import { ObjectKernel, Plugin, IHttpServer, ObjectKernelConfig } from '@objectstack/core';
-
-export interface RuntimeConfig {
-    /**
-     * Optional existing server instance (e.g. Hono, Express app)
-     * If provided, Runtime will use it as the 'http.server' service.
-     * If not provided, Runtime expects a server plugin (like HonoServerPlugin) to be registered manually.
-     */
-    server?: IHttpServer;
-
-    /**
-     * Kernel Configuration
-     */
-    kernel?: ObjectKernelConfig;
-}
-
-/**
- * ObjectStack Runtime
- * 
- * High-level entry point for bootstrapping an ObjectStack application.
- * Wraps ObjectKernel and provides standard orchestration for:
- * - HTTP Server binding
- * - Plugin Management
- * 
- * REST API is opt-in — register it explicitly:
- * ```ts
- * import { createRestApiPlugin } from '@objectstack/rest';
- * runtime.use(createRestApiPlugin());
- * ```
- */
-export class Runtime {
-    readonly kernel: ObjectKernel;
-    
-    constructor(config: RuntimeConfig = {}) {
-        this.kernel = new ObjectKernel(config.kernel);
-        
-        // If external server provided, register it immediately
-        if (config.server) {
-             this.kernel.registerService('http.server', config.server);
-        }
-    }
-    
-    /**
-     * Register a plugin
-     */
-    use(plugin: Plugin) {
-        this.kernel.use(plugin);
-        return this;
-    }
-    
-    /**
-     * Start the runtime
-     * 1. Initializes all plugins (init phase)
-     * 2. Starts all plugins (start phase)
-     */
-    async start() {
-        await this.kernel.bootstrap();
-        return this;
-    }
-    
-    /**
-     * Get the kernel instance
-     */
-    getKernel() {
-        return this.kernel;
-    }
-}