@modularizer/plat 0.15.0 → 0.16.0

package/dist/server/server.js

@@ -1,5 +1,6 @@
 import express from "express";
 import { createServer as createHttpServer } from 'node:http';
+import nodePath from 'node:path';
 import { applyRateLimitCheck, applyRateLimitRefund, createInMemoryRateLimit } from "./rate-limit/index.js";
 import { applyTokenLimitCheck, applyTokenLimitFailure, applyTokenLimitResponse, createInMemoryTokenLimit } from "./token-limit/index.js";
 import { applyCacheCheck, applyCacheStore, createInMemoryCache } from "./cache/index.js";
@@ -14,10 +15,12 @@ import { DEFAULT_RPC_PATH } from '../rpc.js';
 import { InMemoryCallSessionController } from "./call-sessions.js";
 import { createRpcProtocolPlugin } from './rpc-protocol-plugin.js';
 import { createFileQueueProtocolPlugin } from './file-queue-protocol-plugin.js';
+import { createWebRTCProtocolPlugin } from './webrtc-plugin.js';
 import { PLATOperationRegistry } from './operation-registry.js';
 import { PLATServerCore } from './core.js';
 import { createAuthorityServerController } from './authority-server.js';
 import { isFileResponse } from '../static/file-response.js';
+import { createWildcardRouteMatcher } from './routing.js';
 export class PLATServer {
     app;
     options;
@@ -31,6 +34,8 @@ export class PLATServer {
     staticFolders = [];
     pendingRootFolder;
     core;
+    teardownRuntimeCallbacks = [];
+    serverCreatedAt = Date.now();
     constructor(options = {}, ...ControllerClasses) {
         this.app = express();
         this.options = {
@@ -187,6 +192,7 @@ export class PLATServer {
         }
         // General help endpoint
         this.app.get('/help', (req, res) => {
+            const origin = `${req.protocol}://${req.headers.host ?? ''}`;
             const help = {
                 endpoints: {
                     'GET /endpoints': 'List all available API endpoints with descriptions',
@@ -225,12 +231,12 @@ export class PLATServer {
                     },
                 },
                 examples: [
-                    'curl http://localhost:3000/endpoints',
-                    'curl "http://localhost:3000/endpoints?method=POST"',
-                    'curl "http://localhost:3000/endpoints?search=user"',
-                    'curl "http://localhost:3000/endpoints?format=json"',
-                    'curl "http://localhost:3000/openapi-jq?filter=.paths"',
-                    'curl "http://localhost:3000/api/users?help=true"',
+                    `curl ${origin}/endpoints`,
+                    `curl "${origin}/endpoints?method=POST"`,
+                    `curl "${origin}/endpoints?search=user"`,
+                    `curl "${origin}/endpoints?format=json"`,
+                    `curl "${origin}/openapi-jq?filter=.paths"`,
+                    `curl "${origin}/api/users?help=true"`,
                 ],
             };
             res.json(help);
@@ -407,12 +413,24 @@ export class PLATServer {
      * No path parameters in decorators - all routing is done by method names.
      */
     register(...ControllerClasses) {
+        const exactRegistrations = [];
+        const wildcardRegistrations = [];
         for (const registered of this.core.registerControllers(...ControllerClasses)) {
             const { operation: rpcOperation, route } = registered;
-            const { methodName, path: fullPath } = route;
-            const httpMethod = route.method.toLowerCase();
+            const { methodName } = route;
             const routeMeta = rpcOperation.routeMeta;
-            const handler = async (req, res) => {
+            const handler = async (req, res, next) => {
+                if (rpcOperation.isWildcard) {
+                    const resolved = this.resolveOperation({
+                        method: req.method,
+                        path: req.path,
+                    });
+                    if (!resolved || resolved.methodName !== rpcOperation.methodName) {
+                        next();
+                        return;
+                    }
+                }
+                const requestPath = rpcOperation.isWildcard ? req.path : rpcOperation.path;
                 let input = {
                     ...req.params,
                     ...req.query,
@@ -436,7 +454,7 @@ export class PLATServer {
                         const session = this.options.calls.controller.create({
                             operationId: methodName,
                             method: req.method,
-                            path: fullPath,
+                            path: requestPath,
                         });
                         const abortController = new AbortController();
                         this.options.calls.controller.setCancel(session.id, () => abortController.abort());
@@ -454,7 +472,7 @@ export class PLATServer {
                         const deferredEnvelope = {
                             protocol: 'http',
                             method: req.method,
-                            path: fullPath,
+                            path: requestPath,
                             headers: req.headers,
                             input,
                             ctx,
@@ -484,7 +502,7 @@ export class PLATServer {
                     const execution = await this.dispatchTransportCall(rpcOperation, {
                         protocol: 'http',
                         method: req.method,
-                        path: fullPath,
+                        path: requestPath,
                         headers: req.headers,
                         input,
                         ctx,
@@ -535,10 +553,31 @@ export class PLATServer {
                     }
                 }
             };
-            // Register route with Express (canonical route)
-            this.app[httpMethod](fullPath, handler);
+            if (rpcOperation.isWildcard) {
+                wildcardRegistrations.push({ registered, handler });
+            }
+            else {
+                exactRegistrations.push({ registered, handler });
+            }
+        }
+        for (const { registered, handler } of exactRegistrations) {
+            this.registerExpressRoute(registered.route.method, registered.operation.path, handler);
             for (const variant of registered.variants) {
-                this.app[variant.method.toLowerCase()](variant.path, handler);
+                this.registerExpressRoute(variant.method, variant.path, handler);
+            }
+        }
+        for (const { registered, handler } of wildcardRegistrations) {
+            const wildcardRoutes = [
+                { method: registered.operation.method, path: registered.operation.path },
+                ...registered.variants,
+            ];
+            const seen = new Set();
+            for (const wildcardRoute of wildcardRoutes) {
+                const key = `${wildcardRoute.method} ${wildcardRoute.path}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                this.registerWildcardExpressRoute(wildcardRoute.method, wildcardRoute.path, handler);
             }
         }
         // Register static folder routes (after all API routes for correct priority)
@@ -556,39 +595,144 @@ export class PLATServer {
      * Create CORS middleware
      */
     createCORSMiddleware(corsConfig) {
-        const config = corsConfig === true
-            ? { origin: '*', credentials: false }
-            : corsConfig === false
+        // If corsConfig is a function, handle per-request
+        if (typeof corsConfig === 'function') {
+            return async (req, res, next) => {
+                try {
+                    const result = await corsConfig(req);
+                    if (!result) {
+                        // CORS not allowed
+                        if (req.method === 'OPTIONS') {
+                            res.status(403).end();
+                            return;
+                        }
+                        return next();
+                    }
+                    const config = typeof result === 'object' ? result : { origin: '*' };
+                    const requestOrigin = req.headers.origin;
+                    let origin = undefined;
+                    if (typeof config.origin === 'string') {
+                        if (config.origin === '*' && config.credentials) {
+                            // Invalid: do not set header
+                            origin = undefined;
+                        }
+                        else {
+                            origin = config.origin;
+                        }
+                    }
+                    else if (Array.isArray(config.origin)) {
+                        if (requestOrigin && config.origin.includes(requestOrigin)) {
+                            origin = requestOrigin;
+                        }
+                        else if (!config.credentials) {
+                            origin = config.origin[0] ?? '*';
+                        }
+                    }
+                    else if (typeof config.origin === 'function') {
+                        if (requestOrigin && config.origin(requestOrigin)) {
+                            origin = requestOrigin;
+                        }
+                    }
+                    if (origin) {
+                        res.setHeader('Access-Control-Allow-Origin', origin);
+                        res.setHeader('Vary', 'Origin');
+                    }
+                    if (config.credentials) {
+                        res.setHeader('Access-Control-Allow-Credentials', 'true');
+                    }
+                    if (config.methods) {
+                        res.setHeader('Access-Control-Allow-Methods', config.methods.join(', '));
+                    }
+                    else if (req.method === 'OPTIONS') {
+                        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS, PATCH');
+                    }
+                    if (config.headers) {
+                        res.setHeader('Access-Control-Allow-Headers', config.headers.join(', '));
+                    }
+                    else if (req.method === 'OPTIONS' && req.headers['access-control-request-headers']) {
+                        res.setHeader('Access-Control-Allow-Headers', req.headers['access-control-request-headers']);
+                    }
+                    if (config.exposedHeaders) {
+                        res.setHeader('Access-Control-Expose-Headers', config.exposedHeaders.join(', '));
+                    }
+                    if (config.maxAge) {
+                        res.setHeader('Access-Control-Max-Age', String(config.maxAge));
+                    }
+                    if (req.method === 'OPTIONS') {
+                        res.status(204).end();
+                        return;
+                    }
+                    next();
+                }
+                catch (err) {
+                    // On error, disallow CORS
+                    if (req.method === 'OPTIONS') {
+                        res.status(500).end();
+                        return;
+                    }
+                    next();
+                }
+            };
+        }
+        else {
+            // Static config (original logic)
+            const config = corsConfig === true
                 ? { origin: '*', credentials: false }
-                : corsConfig;
-        return (req, res, next) => {
-            const origin = typeof config.origin === 'string'
-                ? config.origin
-                : Array.isArray(config.origin)
-                    ? config.origin[0] ?? '*'
-                    : '*';
-            res.setHeader('Access-Control-Allow-Origin', origin);
-            if (config.credentials) {
-                res.setHeader('Access-Control-Allow-Credentials', 'true');
-            }
-            if (config.methods) {
-                res.setHeader('Access-Control-Allow-Methods', config.methods.join(', '));
-            }
-            if (config.headers) {
-                res.setHeader('Access-Control-Allow-Headers', config.headers.join(', '));
-            }
-            if (config.exposedHeaders) {
-                res.setHeader('Access-Control-Expose-Headers', config.exposedHeaders.join(', '));
-            }
-            if (config.maxAge) {
-                res.setHeader('Access-Control-Max-Age', String(config.maxAge));
-            }
-            if (req.method === 'OPTIONS') {
-                res.status(200).end();
-                return;
-            }
-            next();
-        };
+                : corsConfig === false
+                    ? { origin: '*', credentials: false }
+                    : corsConfig;
+            return (req, res, next) => {
+                const requestOrigin = req.headers.origin;
+                let origin = undefined;
+                if (typeof config.origin === 'string') {
+                    if (config.origin === '*' && config.credentials) {
+                        // Invalid: do not set header
+                        origin = undefined;
+                    }
+                    else {
+                        origin = config.origin;
+                    }
+                }
+                else if (Array.isArray(config.origin)) {
+                    if (requestOrigin && config.origin.includes(requestOrigin)) {
+                        origin = requestOrigin;
+                    }
+                    else if (!config.credentials) {
+                        origin = config.origin[0] ?? '*';
+                    }
+                }
+                if (origin) {
+                    res.setHeader('Access-Control-Allow-Origin', origin);
+                    res.setHeader('Vary', 'Origin');
+                }
+                if (config.credentials) {
+                    res.setHeader('Access-Control-Allow-Credentials', 'true');
+                }
+                if (config.methods) {
+                    res.setHeader('Access-Control-Allow-Methods', config.methods.join(', '));
+                }
+                else if (req.method === 'OPTIONS') {
+                    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS, PATCH');
+                }
+                if (config.headers) {
+                    res.setHeader('Access-Control-Allow-Headers', config.headers.join(', '));
+                }
+                else if (req.method === 'OPTIONS' && req.headers['access-control-request-headers']) {
+                    res.setHeader('Access-Control-Allow-Headers', req.headers['access-control-request-headers']);
+                }
+                if (config.exposedHeaders) {
+                    res.setHeader('Access-Control-Expose-Headers', config.exposedHeaders.join(', '));
+                }
+                if (config.maxAge) {
+                    res.setHeader('Access-Control-Max-Age', String(config.maxAge));
+                }
+                if (req.method === 'OPTIONS') {
+                    res.status(204).end();
+                    return;
+                }
+                next();
+            };
+        }
     }
     /**
      * Extract path parameters from a path string
@@ -942,7 +1086,7 @@ export class PLATServer {
         return this.executeOperation({
             methodName: operation.methodName,
             controllerTag: operation.controllerTag,
-            fullPath: operation.path,
+            fullPath: envelope.path,
             transportMethod: envelope.method,
             routeMeta: operation.routeMeta,
             controllerMeta: operation.controllerMeta,
@@ -1057,7 +1201,7 @@ export class PLATServer {
             openapi: '3.1.0',
             info: {
                 title: 'plat API',
-                version: '0.15.0',
+                version: '0.16.0',
             },
             paths,
         };
@@ -1118,6 +1262,13 @@ export class PLATServer {
                 config: this.options.fileQueue || undefined,
             }),
         ];
+        if (this.options.webrtc) {
+            builtInPlugins.push(createWebRTCProtocolPlugin(this.options.webrtc, {
+                getOpenAPISpec: () => this.options.openapi,
+                getToolsList: () => Array.from(this.tools.values()),
+                getServerStartedAt: () => this.serverCreatedAt,
+            }));
+        }
         const transportRuntime = this.createTransportRuntime();
         const allPlugins = [...builtInPlugins, ...(this.options.protocolPlugins ?? [])];
         for (const plugin of allPlugins) {
@@ -1127,10 +1278,13 @@ export class PLATServer {
             void plugin.attach?.(transportRuntime, hostContext);
             void plugin.start?.(transportRuntime);
         }
+        this.teardownRuntimeCallbacks = allPlugins
+            .filter((p) => typeof p.teardown === 'function')
+            .map((p) => () => p.teardown(transportRuntime));
         // Register root static folder as lowest-priority fallback
         if (this.pendingRootFolder) {
             const rootFolder = this.pendingRootFolder;
-            this.app.get('*', async (req, res, next) => {
+            this.app.get(/.*/, async (req, res, next) => {
                 const subPath = req.path.replace(/^\//, '');
                 try {
                     const fileResponse = await rootFolder.folder.resolve(subPath);
@@ -1150,6 +1304,15 @@ export class PLATServer {
         return this;
     }
     async close() {
+        for (const cb of this.teardownRuntimeCallbacks) {
+            try {
+                await cb();
+            }
+            catch (err) {
+                this.logger.error('[plugin teardown] error during close', err);
+            }
+        }
+        this.teardownRuntimeCallbacks = [];
         if (!this.httpServer)
             return;
         await new Promise((resolve, reject) => {
@@ -1162,6 +1325,17 @@ export class PLATServer {
         });
         this.httpServer = undefined;
     }
+    registerExpressRoute(method, path, handler) {
+        this.app[method.toLowerCase()](path, handler);
+    }
+    registerWildcardExpressRoute(method, basePath, handler) {
+        const matcher = createWildcardRouteMatcher(basePath);
+        if (method === '*') {
+            this.app.all(matcher, handler);
+            return;
+        }
+        this.registerExpressRoute(method, matcher, handler);
+    }
     registerStaticFolderRoutes() {
         for (const sf of this.staticFolders) {
             if (sf.name === 'root') {
@@ -1186,7 +1360,7 @@ export class PLATServer {
                 }
             };
             this.app.get(prefix, handler);
-            this.app.get(`${prefix}/*`, handler);
+            this.app.get(new RegExp(`^${prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/.*`), handler);
         }
     }
     sendFileResponse(res, fileResponse) {
@@ -1197,9 +1371,11 @@ export class PLATServer {
         if (fileResponse.maxAge !== undefined) {
             res.setHeader('Cache-Control', `public, max-age=${fileResponse.maxAge}`);
         }
+        if (fileResponse.status && fileResponse.status !== 200) {
+            res.status(fileResponse.status);
+        }
         if (fileResponse.kind === 'path') {
-            const path = require('node:path');
-            res.sendFile(path.resolve(fileResponse.source));
+            res.sendFile(nodePath.resolve(fileResponse.source));
         }
         else {
             const content = fileResponse.source;