@objectstack/runtime 0.6.0 → 0.7.1

package/dist/middleware.js

@@ -0,0 +1,176 @@
+/**
+ * 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

@@ -0,0 +1,74 @@
+import { IHttpServer } from '@objectstack/core';
+import { RouteManager } from './route-manager';
+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").RouteEntry[];
+}