@objectstack/runtime 1.0.4 → 1.0.5

package/dist/http-server.d.ts

@@ -1,84 +0,0 @@
-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 declare 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);
-    /**
-     * 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;
-    /**
-     * Register a POST route handler
-     * @param path - Route path
-     * @param handler - Route handler function
-     */
-    post(path: string, handler: RouteHandler): void;
-    /**
-     * Register a PUT route handler
-     * @param path - Route path
-     * @param handler - Route handler function
-     */
-    put(path: string, handler: RouteHandler): void;
-    /**
-     * Register a DELETE route handler
-     * @param path - Route path
-     * @param handler - Route handler function
-     */
-    delete(path: string, handler: RouteHandler): void;
-    /**
-     * Register a PATCH route handler
-     * @param path - Route path
-     * @param handler - Route handler function
-     */
-    patch(path: string, handler: RouteHandler): void;
-    /**
-     * 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;
-    /**
-     * Start the HTTP server
-     * @param port - Port number to listen on
-     * @returns Promise that resolves when server is ready
-     */
-    listen(port: number): Promise<void>;
-    /**
-     * Stop the HTTP server
-     * @returns Promise that resolves when server is stopped
-     */
-    close(): Promise<void>;
-    /**
-     * Get registered routes
-     * @returns Map of route keys to handlers
-     */
-    getRoutes(): Map<string, RouteHandler>;
-    /**
-     * Get registered middlewares
-     * @returns Array of middleware functions
-     */
-    getMiddlewares(): Middleware[];
-}

package/dist/http-server.js

@@ -1,125 +0,0 @@
-/**
- * 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 {
-    /**
-     * Create an HTTP server wrapper
-     * @param server - The underlying server implementation (Hono, Express, etc.)
-     */
-    constructor(server) {
-        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, handler) {
-        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, handler) {
-        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, handler) {
-        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, handler) {
-        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, handler) {
-        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, handler) {
-        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) {
-        await this.server.listen(port);
-    }
-    /**
-     * Stop the HTTP server
-     * @returns Promise that resolves when server is stopped
-     */
-    async close() {
-        if (this.server.close) {
-            await this.server.close();
-        }
-    }
-    /**
-     * Get registered routes
-     * @returns Map of route keys to handlers
-     */
-    getRoutes() {
-        return new Map(this.routes);
-    }
-    /**
-     * Get registered middlewares
-     * @returns Array of middleware functions
-     */
-    getMiddlewares() {
-        return [...this.middlewares];
-    }
-}

package/dist/middleware.d.ts

@@ -1,111 +0,0 @@
-import { Middleware } 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 declare class MiddlewareManager {
-    private middlewares;
-    constructor();
-    /**
-     * Register middleware with configuration
-     * @param config - Middleware configuration
-     * @param middleware - Middleware function
-     */
-    register(config: MiddlewareConfig, middleware: Middleware): void;
-    /**
-     * Unregister middleware by name
-     * @param name - Middleware name
-     */
-    unregister(name: string): void;
-    /**
-     * Enable middleware by name
-     * @param name - Middleware name
-     */
-    enable(name: string): void;
-    /**
-     * Disable middleware by name
-     * @param name - Middleware name
-     */
-    disable(name: string): void;
-    /**
-     * Get middleware entry by name
-     * @param name - Middleware name
-     */
-    get(name: string): MiddlewareEntry | undefined;
-    /**
-     * Get all middleware entries
-     */
-    getAll(): MiddlewareEntry[];
-    /**
-     * Get middleware by type
-     * @param type - Middleware type
-     */
-    getByType(type: MiddlewareType): MiddlewareEntry[];
-    /**
-     * Get middleware chain sorted by order
-     * Returns only enabled middleware
-     */
-    getMiddlewareChain(): Middleware[];
-    /**
-     * Get middleware chain with path filtering
-     * @param path - Request path to match against
-     */
-    getMiddlewareChainForPath(path: string): Middleware[];
-    /**
-     * Match path against pattern (simple glob matching)
-     * @param path - Request path
-     * @param pattern - Pattern to match (supports * wildcard)
-     */
-    private matchPath;
-    /**
-     * Clear all middleware
-     */
-    clear(): void;
-    /**
-     * Get middleware count
-     */
-    count(): number;
-    /**
-     * Create a composite middleware from the chain
-     * This can be used to apply all middleware at once
-     */
-    createCompositeMiddleware(): Middleware;
-}
-export {};

package/dist/middleware.js

@@ -1,176 +0,0 @@
-/**
- * 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 {
-    constructor() {
-        this.middlewares = new Map();
-    }
-    /**
-     * Register middleware with configuration
-     * @param config - Middleware configuration
-     * @param middleware - Middleware function
-     */
-    register(config, middleware) {
-        const entry = {
-            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) {
-        this.middlewares.delete(name);
-    }
-    /**
-     * Enable middleware by name
-     * @param name - Middleware name
-     */
-    enable(name) {
-        const entry = this.middlewares.get(name);
-        if (entry) {
-            entry.enabled = true;
-        }
-    }
-    /**
-     * Disable middleware by name
-     * @param name - Middleware name
-     */
-    disable(name) {
-        const entry = this.middlewares.get(name);
-        if (entry) {
-            entry.enabled = false;
-        }
-    }
-    /**
-     * Get middleware entry by name
-     * @param name - Middleware name
-     */
-    get(name) {
-        return this.middlewares.get(name);
-    }
-    /**
-     * Get all middleware entries
-     */
-    getAll() {
-        return Array.from(this.middlewares.values());
-    }
-    /**
-     * Get middleware by type
-     * @param type - Middleware type
-     */
-    getByType(type) {
-        return this.getAll().filter(entry => entry.type === type);
-    }
-    /**
-     * Get middleware chain sorted by order
-     * Returns only enabled middleware
-     */
-    getMiddlewareChain() {
-        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) {
-        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)
-     */
-    matchPath(path, pattern) {
-        // 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() {
-        this.middlewares.clear();
-    }
-    /**
-     * Get middleware count
-     */
-    count() {
-        return this.middlewares.size;
-    }
-    /**
-     * Create a composite middleware from the chain
-     * This can be used to apply all middleware at once
-     */
-    createCompositeMiddleware() {
-        const chain = this.getMiddlewareChain();
-        return async (req, res, next) => {
-            let index = 0;
-            const executeNext = async () => {
-                if (index >= chain.length) {
-                    await next();
-                    return;
-                }
-                const middleware = chain[index++];
-                await middleware(req, res, executeNext);
-            };
-            await executeNext();
-        };
-    }
-}

package/dist/rest-server.d.ts

@@ -1,74 +0,0 @@
-import { IHttpServer } from '@objectstack/core';
-import { RouteManager } from './route-manager.js';
-import { RestServerConfig } from '@objectstack/spec/api';
-import { ObjectStackProtocol } from '@objectstack/spec/api';
-/**
- * RestServer
- *
- * Provides automatic REST API endpoint generation for ObjectStack.
- * Generates standard RESTful CRUD endpoints, metadata endpoints, and batch operations
- * based on the configured protocol provider.
- *
- * Features:
- * - Automatic CRUD endpoint generation (GET, POST, PUT, PATCH, DELETE)
- * - Metadata API endpoints (/meta)
- * - Batch operation endpoints (/batch, /createMany, /updateMany, /deleteMany)
- * - Discovery endpoint
- * - Configurable path prefixes and patterns
- *
- * @example
- * const restServer = new RestServer(httpServer, protocolProvider, {
- *   api: {
- *     version: 'v1',
- *     basePath: '/api'
- *   },
- *   crud: {
- *     dataPrefix: '/data'
- *   }
- * });
- *
- * restServer.registerRoutes();
- */
-export declare class RestServer {
-    private server;
-    private protocol;
-    private config;
-    private routeManager;
-    constructor(server: IHttpServer, protocol: ObjectStackProtocol, config?: RestServerConfig);
-    /**
-     * Normalize configuration with defaults
-     */
-    private normalizeConfig;
-    /**
-     * Get the full API base path
-     */
-    private getApiBasePath;
-    /**
-     * Register all REST API routes
-     */
-    registerRoutes(): void;
-    /**
-     * Register discovery endpoints
-     */
-    private registerDiscoveryEndpoints;
-    /**
-     * Register metadata endpoints
-     */
-    private registerMetadataEndpoints;
-    /**
-     * Register CRUD endpoints for data operations
-     */
-    private registerCrudEndpoints;
-    /**
-     * Register batch operation endpoints
-     */
-    private registerBatchEndpoints;
-    /**
-     * Get the route manager
-     */
-    getRouteManager(): RouteManager;
-    /**
-     * Get all registered routes
-     */
-    getRoutes(): import("./route-manager.js").RouteEntry[];
-}