@loutrejs/loutre 0.6.0 → 0.8.0

package/dist/websocket/extension.js

@@ -5,7 +5,7 @@ import { compareHttpPathSpecificity, HttpPathDecodeError, matchHttpPath, normali
 export const WEBSOCKET_SERVER = runtimeCapability('websocket.server');
 export const websocketExtension = defineExecutionExtension({
     kind: 'execution-extension',
-    abiVersion: '1',
+    abiVersion: '2',
     name: 'loutre:websocket',
     compile(definition, context) {
         return {
@@ -101,24 +101,23 @@ export const websocket = Object.freeze({
     serverCapability: WEBSOCKET_SERVER,
     bindServer: bindWebSocketServer,
 });
-function compileRouteTree(tree, parentPath = '', parentResponses = {}, prefix = '', routeNames = new Set()) {
+function compileRouteTree(tree, parentPath = '', prefix = '', routeNames = new Set()) {
     return Object.entries(tree).flatMap(([name, node]) => {
+        if ('request' in node || 'responses' in node)
+            throw new TypeError('WebSocket v2ではhandshakeを使用してください。');
         if (isBranch(node)) {
             const branchPath = node.path ?? '';
             if (branchPath !== '')
                 parseHttpPath(branchPath);
-            assertNoInheritedResponseCollision(name, parentResponses, node.responses ?? {});
-            return compileRouteTree(node.routes, joinPath(parentPath, branchPath), { ...parentResponses, ...node.responses }, prefix ? `${prefix}.${name}` : name, routeNames);
+            return compileRouteTree(node.routes, joinPath(parentPath, branchPath), prefix ? `${prefix}.${name}` : name, routeNames);
         }
         parseHttpPath(node.path);
         const path = joinPath(parentPath, node.path);
         const segments = parseHttpPath(path);
-        assertExactPathParams(path, segments, node.request?.params);
-        assertNoInheritedResponseCollision(name, parentResponses, node.responses ?? {});
+        assertExactPathParams(path, segments, node.handshake?.params);
         const routeName = prefix ? `${prefix}.${name}` : name;
-        if (routeNames.has(routeName)) {
+        if (routeNames.has(routeName))
             throw new TypeError(`Duplicate nested WebSocket route name: ${routeName}`);
-        }
         routeNames.add(routeName);
         return [
             Object.freeze({
@@ -126,13 +125,9 @@ function compileRouteTree(tree, parentPath = '', parentResponses = {}, prefix =
                 path,
                 normalizedPath: normalizeHttpPath(segments),
                 segments,
-                ...(node.request === undefined
+                ...(node.handshake === undefined
                     ? {}
-                    : { request: snapshotWebSocketRequest(node.request) }),
-                responses: snapshotWebSocketResponses({
-                    ...parentResponses,
-                    ...node.responses,
-                }),
+                    : { handshake: snapshotHandshake(node.handshake) }),
                 ...(node.messages === undefined
                     ? {}
                     : { messages: Object.freeze({ ...node.messages }) }),
@@ -152,27 +147,17 @@ function assertExactPathParams(path, segments, params) {
         throw new TypeError(`WebSocket ${path} request params must exactly match path parameters.`);
     }
 }
-function assertNoInheritedResponseCollision(nodeName, inherited, declared) {
-    for (const name of Object.keys(declared)) {
-        if (name in inherited) {
-            throw new TypeError(`Duplicate inherited WebSocket response ${name} at ${nodeName}.`);
-        }
-    }
-}
-function snapshotWebSocketRequest(request) {
+function snapshotHandshake(handshake) {
     return Object.freeze({
-        ...request,
-        ...(request.params === undefined
+        ...handshake,
+        ...(handshake.params === undefined
+            ? {}
+            : { params: Object.freeze({ ...handshake.params }) }),
+        ...(handshake.protocols === undefined
             ? {}
-            : { params: Object.freeze({ ...request.params }) }),
+            : { protocols: Object.freeze([...handshake.protocols]) }),
     });
 }
-function snapshotWebSocketResponses(responses) {
-    return Object.freeze(Object.fromEntries(Object.entries(responses).map(([name, response]) => [
-        name,
-        Object.freeze({ ...response }),
-    ])));
-}
 function isBranch(node) {
     return 'routes' in node;
 }
@@ -234,13 +219,28 @@ function createWebSocketRuntime(executions, driver, applicationRuntime) {
             if (state !== 'running') {
                 return Response.json({ error: 'Service Unavailable' }, { status: 503 });
             }
+            const offered = (request.headers.get('sec-websocket-protocol') ?? '')
+                .split(',')
+                .map((value) => value.trim())
+                .filter(Boolean);
+            const protocol = match.route.handshake?.protocols?.find((value) => offered.includes(value));
+            if (match.route.handshake?.protocols?.length && protocol === undefined) {
+                return new Response('WebSocket subprotocolが一致しません。', {
+                    status: 400,
+                });
+            }
             const completePendingIngress = ingress.enter();
             if (!completePendingIngress) {
                 return Response.json({ error: 'Service Unavailable' }, { status: 503 });
             }
             let lease;
             try {
-                lease = applicationRuntime.beginExecution();
+                lease = applicationRuntime.beginExecution({
+                    executionId: match.executionId,
+                    executionKind: 'websocket.session',
+                    graphNodeId: match.executionId,
+                    name: `WS ${match.route.path}`,
+                });
             }
             catch (error) {
                 completePendingIngress();
@@ -248,14 +248,15 @@ function createWebSocketRuntime(executions, driver, applicationRuntime) {
             }
             let upgraded;
             try {
-                upgraded = await driver.upgrade(request);
+                upgraded = await driver.upgrade(request, protocol === undefined ? {} : { protocol });
             }
             catch (error) {
+                lease.fail?.(error);
                 lease.complete();
                 completePendingIngress();
                 throw error;
             }
-            const session = createSession(upgraded.connection, match.route, input, lease, handlers.get(match.executionId)?.[match.route.name]);
+            const session = createSession(upgraded.connection, request, applicationRuntime, match.route, input, lease, handlers.get(match.executionId)?.[match.route.name], lease.run);
             sessions.add(session.active);
             void session.completion.then(() => sessions.delete(session.active), () => sessions.delete(session.active));
             completePendingIngress();
@@ -275,14 +276,19 @@ function createWebSocketRuntime(executions, driver, applicationRuntime) {
             const results = await Promise.allSettled([...sessions].map(async (session) => {
                 const graceful = session
                     .close(1001, 'Going Away')
+                    .then(() => session.completion)
                     .then(() => true)
                     .catch(() => false);
+                let timer;
                 const completed = gracefulTimeoutMs === 0
                     ? false
                     : await Promise.race([
                         graceful,
-                        delay(gracefulTimeoutMs).then(() => false),
+                        new Promise((resolve) => {
+                            timer = setTimeout(() => resolve(false), gracefulTimeoutMs);
+                        }),
                     ]);
+                clearTimeout(timer);
                 if (!completed)
                     await session.terminate();
                 await session.completion.catch(() => undefined);
@@ -312,19 +318,19 @@ function findRoute(routes, request) {
     return undefined;
 }
 async function validateOpeningRequest(request, rawParams, route) {
-    const params = route.request?.params
-        ? Object.fromEntries(await Promise.all(Object.entries(route.request.params).map(async ([name, schema]) => [
+    const params = route.handshake?.params
+        ? Object.fromEntries(await Promise.all(Object.entries(route.handshake.params).map(async ([name, schema]) => [
             name,
             await validateSchema(schema, rawParams[name]),
         ])))
         : rawParams;
     const url = new URL(request.url);
     const rawQuery = decodeQuery(url.searchParams);
-    const query = route.request?.query
-        ? await validateSchema(route.request.query, rawQuery)
+    const query = route.handshake?.query
+        ? await validateSchema(route.handshake.query, rawQuery)
         : rawQuery;
-    const headers = route.request?.headers
-        ? await validateSchema(route.request.headers, Object.fromEntries(request.headers))
+    const headers = route.handshake?.headers
+        ? await validateSchema(route.handshake.headers, Object.fromEntries(request.headers))
         : request.headers;
     return { params, query, headers };
 }
@@ -341,7 +347,15 @@ function decodeQuery(searchParams) {
     }
     return query;
 }
-function createSession(connection, route, input, lease, handler) {
+function createSession(connection, request, applicationRuntime, route, input, lease, handler, runInExecution) {
+    const session = Object.freeze({
+        id: `ws_${crypto.randomUUID()}`,
+        protocol: connection.protocol,
+    });
+    lease.annotate?.({
+        'websocket.session.id': session.id,
+        'websocket.protocol': session.protocol,
+    });
     let state = 'open';
     let transportFailed = false;
     let sendTail = Promise.resolve();
@@ -352,6 +366,7 @@ function createSession(connection, route, input, lease, handler) {
         return normalizeCloseInfo(info);
     }, (error) => {
         state = 'closed';
+        lease.fail?.(error);
         lease.abort(error);
         throw error;
     });
@@ -392,6 +407,17 @@ function createSession(connection, route, input, lease, handler) {
     };
     const messages = decodeMessages(connection.messages, route.messages);
     const context = {
+        request,
+        session,
+        protocol: session.protocol,
+        execution: {
+            signal: lease.signal,
+            annotate: (attributes) => lease.annotate?.(attributes),
+            beginOperation: (metadata) => {
+                const begin = () => applicationRuntime.beginOperation?.(metadata) ?? { complete() { } };
+                return lease.run ? lease.run(begin) : begin();
+            },
+        },
         input: {
             ...input,
             ...(route.messages?.input === undefined ? {} : { messages }),
@@ -406,11 +432,13 @@ function createSession(connection, route, input, lease, handler) {
             if (!handler) {
                 throw new Error(`LUTRE_WEBSOCKET_HANDLER_MISSING: ${route.name}`);
             }
-            await handler(context);
+            const invoke = () => handler(context);
+            await (runInExecution ? runInExecution(invoke) : invoke());
             if (state === 'open')
                 await close(1000, '');
         }
-        catch {
+        catch (error) {
+            lease.fail?.(error);
             if (state === 'open')
                 await close(1011, '');
         }
@@ -519,6 +547,3 @@ function webSocketGracefulShutdownBudget(timeoutMs) {
         return 0;
     return Math.min(5_000, Math.max(0, Math.floor(timeoutMs * 0.8)));
 }
-function delay(milliseconds) {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
-}

package/dist/websocket/index.d.ts

@@ -1,3 +1,5 @@
 export { bindWebSocketServer, defineWebSocketContract, defineWebSocketImplementation, WEBSOCKET_SERVER, websocket, websocketExtension, } from './extension.js';
 export { WebSocketConnectionNotOpenError, WebSocketMessageDecodeError, WebSocketMessageEncodeError, } from './errors.js';
-export type { WebSocketBranchDefinition, WebSocketCloseInfo, WebSocketCodecKind, WebSocketConnectionDriver, WebSocketContract, WebSocketDataMessage, WebSocketExecutionDefinition, WebSocketExtensionRuntime, WebSocketHandlerContext, WebSocketHandlers, WebSocketHostApi, WebSocketImplementationDefinition, WebSocketIncomingMessage, WebSocketMessageCodec, WebSocketRouteDefinition, WebSocketRouteTree, WebSocketServerDriver, WebSocketUpgradeResult, } from './extension.js';
+export type { WebSocketBranchDefinition, WebSocketHandshakeDefinition, WebSocketSession, WebSocketUpgradeOptions, WebSocketCloseInfo, WebSocketCodecKind, WebSocketConnectionDriver, WebSocketContract, WebSocketDataMessage, WebSocketExecutionDefinition, WebSocketExtensionRuntime, WebSocketHandlerContext, WebSocketHandlers, WebSocketHostApi, WebSocketImplementationDefinition, WebSocketIncomingMessage, WebSocketMessageCodec, WebSocketRouteDefinition, WebSocketRouteTree, WebSocketServerDriver, WebSocketUpgradeResult, } from './extension.js';
+export { createEventWebSocketConnection, createWebSocketDriverChannel, } from './driver.js';
+export type { EventWebSocket, WebSocketDriverChannel } from './driver.js';

package/dist/websocket/index.js

@@ -1,2 +1,3 @@
 export { bindWebSocketServer, defineWebSocketContract, defineWebSocketImplementation, WEBSOCKET_SERVER, websocket, websocketExtension, } from './extension.js';
 export { WebSocketConnectionNotOpenError, WebSocketMessageDecodeError, WebSocketMessageEncodeError, } from './errors.js';
+export { createEventWebSocketConnection, createWebSocketDriverChannel, } from './driver.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loutrejs/loutre",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "license": "MIT",
   "type": "module",
   "files": [
@@ -20,6 +20,10 @@
       "types": "./dist/graph/index.d.ts",
       "import": "./dist/graph/index.js"
     },
+    "./devtools": {
+      "types": "./dist/devtools/index.d.ts",
+      "import": "./dist/devtools/index.js"
+    },
     "./runtime": {
       "types": "./dist/runtime/index.d.ts",
       "import": "./dist/runtime/index.js"
@@ -44,10 +48,6 @@
       "types": "./dist/adapters/bun.d.ts",
       "import": "./dist/adapters/bun.js"
     },
-    "./runtime/deno": {
-      "types": "./dist/adapters/deno.d.ts",
-      "import": "./dist/adapters/deno.js"
-    },
     "./runtime/cloudflare-workers": {
       "types": "./dist/adapters/cloudflare-workers.d.ts",
       "import": "./dist/adapters/cloudflare-workers.js"
@@ -71,7 +71,8 @@
     "provenance": true
   },
   "dependencies": {
-    "@standard-schema/spec": "^1.1.0"
+    "@standard-schema/spec": "^1.1.0",
+    "ts-pattern": "^5.9.0"
   },
   "repository": {
     "type": "git",

package/dist/adapters/deno.d.ts

@@ -1,35 +0,0 @@
-import { type ApplicationDefinition, type BootstrapArguments, type KernelHostedApplication, type RequireApplicationExtension } from '../application/index.js';
-import type { RuntimeCapabilityBinding } from '../core/index.js';
-import { httpExecutionExtension } from '../http/index.js';
-type HttpApplication<TDefinition extends ApplicationDefinition> = RequireApplicationExtension<TDefinition, typeof httpExecutionExtension>;
-export type DenoRuntimeOptions<TDefinition extends ApplicationDefinition> = {
-    readonly application: HttpApplication<TDefinition>;
-    readonly environment?: unknown;
-    readonly capabilities?: readonly RuntimeCapabilityBinding[];
-    readonly forceShutdownTimeoutMs?: number;
-} & BootstrapArguments<TDefinition>;
-export type DenoCreateOptions<TDefinition extends ApplicationDefinition> = DenoRuntimeOptions<TDefinition>;
-export interface DenoServeOptions {
-    readonly port?: number;
-    readonly hostname?: string;
-    readonly shutdownHooks?: boolean;
-}
-export interface DenoBinding {
-    fetch(request: Request): Promise<Response>;
-    close(signal?: string): Promise<void>;
-}
-export interface DenoListenerHandle {
-    readonly port: number;
-}
-export type DenoRuntimeApplication<TDefinition extends ApplicationDefinition = ApplicationDefinition> = KernelHostedApplication<TDefinition> & {
-    serve(options?: DenoServeOptions): Promise<DenoListenerHandle>;
-};
-export declare const denoRuntime: {
-    readonly runtime: 'deno';
-    readonly capabilities: Set<string>;
-    readonly bind: typeof bind;
-    readonly create: typeof create;
-};
-declare function bind<const TDefinition extends ApplicationDefinition>(options: DenoRuntimeOptions<TDefinition>): DenoBinding;
-declare function create<const TDefinition extends ApplicationDefinition>(options: DenoCreateOptions<TDefinition>): Promise<DenoRuntimeApplication<TDefinition>>;
-export {};

package/dist/adapters/deno.js

@@ -1,231 +0,0 @@
-import { createKernelApplication, } from '../application/index.js';
-import { bindApplicationCapability } from '../application/kernel-internal.js';
-import { httpExecutionExtension } from '../http/index.js';
-import { LOUTRE_VERSION, startStartupPresentation } from '../presentation.js';
-import { assertRuntimeEngine } from '../runtime/engine.js';
-import { serverUrl } from '../runtime/server-url.js';
-import { canRetryOnNextPort, initialServerPort, } from '../runtime/server-port.js';
-export const denoRuntime = {
-    runtime: 'deno',
-    capabilities: new Set([
-        'http.server',
-        'http.request.streaming',
-        'http.response.streaming',
-        'stream.readable',
-        'stream.writable',
-        'runtime.longLived',
-        'runtime.shutdownHook',
-        'env.runtime',
-        'crypto.random',
-    ]),
-    bind,
-    create,
-};
-function bind(options) {
-    assertRuntimeEngine('deno');
-    if (options.application.model.extensions.get(httpExecutionExtension) ===
-        undefined) {
-        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: denoRuntime.bind() requires the HTTP Execution Extension.');
-    }
-    const application = createKernelApplication({
-        ...options,
-        application: options.application,
-        capabilities: [
-            bindApplicationCapability(options.application.model, 'http.server', {
-                runtime: 'deno',
-            }),
-            ...(options.capabilities ?? []),
-        ],
-        environment: 'environment' in options ? options.environment : denoEnvironment(),
-    });
-    let initialization;
-    return {
-        async fetch(request) {
-            initialization ??= application.init();
-            await initialization;
-            return application.http.fetch(request);
-        },
-        close: (signal) => application.close(signal),
-    };
-}
-async function create(options) {
-    assertRuntimeEngine('deno');
-    const deno = denoGlobal();
-    const startedAt = performance.now();
-    const isTTY = deno?.stdout?.isTerminal?.() === true;
-    const presentation = startStartupPresentation({ version: LOUTRE_VERSION }, {
-        terminal: {
-            isTTY,
-            color: isTTY && deno?.env?.get?.('NO_COLOR') === undefined,
-        },
-        write: (value) => console.log(value),
-    });
-    if (options.application.model.extensions.get(httpExecutionExtension) ===
-        undefined) {
-        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: denoRuntime.create() requires the HTTP Execution Extension.');
-    }
-    const hosted = createKernelApplication({
-        ...options,
-        application: options.application,
-        capabilities: [
-            bindApplicationCapability(options.application.model, 'http.server', {
-                runtime: 'deno',
-            }),
-            ...(options.capabilities ?? []),
-        ],
-        environment: 'environment' in options ? options.environment : denoEnvironment(),
-    });
-    await hosted.init();
-    const application = hosted;
-    const http = hosted
-        .http;
-    const closeApplication = application.close.bind(application);
-    let server;
-    let removeShutdownHooks;
-    let serving = false;
-    let closed = false;
-    let closingPromise;
-    let serverClosingPromise;
-    const beginServerClose = () => {
-        if (serverClosingPromise)
-            return serverClosingPromise;
-        if (!server)
-            return Promise.resolve();
-        const closingServer = server;
-        serverClosingPromise = Promise.resolve()
-            .then(() => closingServer.shutdown())
-            .then(() => {
-            if (server === closingServer)
-                server = undefined;
-        }, (error) => {
-            serverClosingPromise = undefined;
-            throw error;
-        });
-        void serverClosingPromise.catch(() => undefined);
-        return serverClosingPromise;
-    };
-    const close = (signal) => {
-        if (closed)
-            return Promise.resolve();
-        if (closingPromise)
-            return closingPromise;
-        closingPromise = (async () => {
-            removeShutdownHooks?.();
-            removeShutdownHooks = undefined;
-            const errors = [];
-            const serverClosing = beginServerClose();
-            try {
-                await closeApplication(signal);
-            }
-            catch (error) {
-                errors.push(error);
-            }
-            if (errors.length === 0) {
-                try {
-                    await serverClosing;
-                }
-                catch (error) {
-                    errors.push(error);
-                }
-            }
-            if (errors.length > 0) {
-                throw new AggregateError(errors, 'Deno runtime shutdown failed');
-            }
-            closed = true;
-        })().catch((error) => {
-            closingPromise = undefined;
-            throw error;
-        });
-        return closingPromise;
-    };
-    const serve = async (serveOptions = {}) => {
-        if (closed) {
-            throw new Error('LUTRE_APP_STOPPED: Application is stopped.');
-        }
-        if (serving) {
-            throw new Error('LUTRE_RUNTIME_ALREADY_SERVING: Deno runtime Application is already serving.');
-        }
-        if (!deno?.serve) {
-            await close().catch(() => undefined);
-            throw new Error('LUTRE_DENO_UNAVAILABLE: Deno.serve() is not available.');
-        }
-        serving = true;
-        try {
-            const requestedPort = serveOptions.port;
-            let port = initialServerPort(requestedPort);
-            while (true) {
-                try {
-                    server = deno.serve({
-                        port,
-                        ...(serveOptions.hostname === undefined
-                            ? {}
-                            : { hostname: serveOptions.hostname }),
-                        onListen: () => undefined,
-                    }, createDenoFetchDriver(http));
-                    break;
-                }
-                catch (error) {
-                    if (requestedPort !== undefined || !canRetryOnNextPort(error, port)) {
-                        throw error;
-                    }
-                    port += 1;
-                }
-            }
-            presentation.ready({
-                server: serverUrl(serveOptions.hostname, port),
-                runtime: `Deno ${deno.version?.deno ?? 'unknown'}`,
-                environment: deno.env?.get?.('DENO_ENV') ??
-                    deno.env?.get?.('NODE_ENV') ??
-                    'development',
-                startupDurationMs: performance.now() - startedAt,
-            });
-            removeShutdownHooks =
-                serveOptions.shutdownHooks === false
-                    ? undefined
-                    : registerDenoShutdownHooks(deno, close);
-            return { port };
-        }
-        catch (error) {
-            await close().catch(() => undefined);
-            throw error;
-        }
-    };
-    Object.assign(application, { serve, close });
-    return application;
-}
-function registerDenoShutdownHooks(deno, close) {
-    if (!deno.addSignalListener || !deno.removeSignalListener) {
-        return undefined;
-    }
-    const handlers = new Map();
-    const remove = () => {
-        for (const [signal, handler] of handlers) {
-            deno.removeSignalListener?.(signal, handler);
-        }
-        handlers.clear();
-    };
-    for (const signal of ['SIGINT', 'SIGTERM']) {
-        const handler = () => {
-            remove();
-            void close(signal);
-        };
-        handlers.set(signal, handler);
-        deno.addSignalListener(signal, handler);
-    }
-    return remove;
-}
-function createDenoFetchDriver(application) {
-    let initialization;
-    return async (request) => {
-        initialization ??= application.initialize?.() ?? Promise.resolve();
-        await initialization;
-        return application.fetch(request);
-    };
-}
-function denoEnvironment() {
-    const deno = denoGlobal();
-    return deno?.env?.toObject ? deno.env.toObject() : undefined;
-}
-function denoGlobal() {
-    return globalThis.Deno;
-}