@loutrejs/loutre 0.7.0 → 0.8.1

package/dist/websocket/driver.js

@@ -0,0 +1,96 @@
+export function createWebSocketDriverChannel(options) {
+    const queue = [];
+    let done = false;
+    let wake;
+    let resolveClosed;
+    const closed = new Promise((resolve) => {
+        resolveClosed = resolve;
+    });
+    return {
+        connection: {
+            ...options,
+            closed,
+            messages: {
+                async *[Symbol.asyncIterator]() {
+                    while (true) {
+                        if (queue.length > 0) {
+                            yield queue.shift();
+                            continue;
+                        }
+                        if (done)
+                            return;
+                        await new Promise((resolve) => {
+                            wake = resolve;
+                        });
+                    }
+                },
+            },
+        },
+        receive(message) {
+            if (done)
+                return;
+            queue.push(message);
+            wake?.();
+            wake = undefined;
+        },
+        finish(info) {
+            if (done)
+                return;
+            done = true;
+            queue.length = 0;
+            resolveClosed(info);
+            wake?.();
+            wake = undefined;
+        },
+    };
+}
+export function createEventWebSocketConnection(socket, protocol, options = {}) {
+    const run = (operation) => options.run ? options.run(operation) : Promise.resolve().then(operation);
+    const opened = socket.readyState === 1
+        ? Promise.resolve()
+        : new Promise((resolve) => socket.addEventListener('open', resolve, { once: true }));
+    socket.binaryType = 'arraybuffer';
+    const channel = createWebSocketDriverChannel({
+        protocol,
+        async send(message) {
+            await Promise.race([
+                opened,
+                channel.connection.closed.then(() => {
+                    throw new Error('WebSocketは終了しました。');
+                }),
+            ]);
+            await run(() => {
+                if (socket.readyState !== 1)
+                    throw new Error('WebSocketはopenではありません。');
+                socket.send(message.data);
+            });
+        },
+        async close(code = 1000, reason = '') {
+            await run(() => socket.close(code, reason));
+        },
+        async terminate() {
+            try {
+                await run(() => options.terminate
+                    ? options.terminate()
+                    : socket.close(1001, 'Going Away'));
+            }
+            finally {
+                channel.finish({ code: 1006, reason: '', wasClean: false });
+            }
+        },
+    });
+    socket.addEventListener('message', ({ data }) => {
+        if (typeof data === 'string')
+            channel.receive({ type: 'text', data });
+        else if (data instanceof ArrayBuffer)
+            channel.receive({ type: 'binary', data: new Uint8Array(data) });
+        else if (ArrayBuffer.isView(data))
+            channel.receive({
+                type: 'binary',
+                data: new Uint8Array(data.buffer, data.byteOffset, data.byteLength),
+            });
+    });
+    socket.addEventListener('close', (info) => channel.finish(info));
+    socket.addEventListener('error', () => channel.finish({ code: 1006, reason: '', wasClean: false }));
+    return channel.connection;
+}

package/dist/websocket/extension.d.ts

@@ -1,5 +1,5 @@
-import { type ExecutionDefinition, type ExecutionExtensionDrainContext, type RuntimeCapabilityBinding, type SchemaOutput, type StandardSchemaV1 } from '../core/index.js';
-import type { HttpExecutionRequestDefinition, HttpExecutionResponseDefinition } from '../http/index.js';
+import { type ExecutionDefinition, type ExecutionContextView, type ExecutionExtensionDrainContext, type RuntimeCapabilityBinding, type SchemaOutput, type StandardSchemaV1 } from '../core/index.js';
+import type { HttpRequestHeadDefinition } from '../http/request-head.js';
 import { type HttpPathSegment } from '../http/index.js';
 export type WebSocketDataMessage = {
     readonly type: 'text';
@@ -14,6 +14,7 @@ export interface WebSocketCloseInfo {
     readonly wasClean: boolean;
 }
 export interface WebSocketConnectionDriver {
+    readonly protocol: string;
     readonly messages: AsyncIterable<WebSocketDataMessage>;
     readonly closed: Promise<WebSocketCloseInfo>;
     send(message: WebSocketDataMessage): Promise<void>;
@@ -24,9 +25,16 @@ export interface WebSocketUpgradeResult {
     readonly response: Response;
     readonly connection: WebSocketConnectionDriver;
 }
+export interface WebSocketUpgradeOptions {
+    readonly protocol?: string;
+}
+export interface WebSocketSession {
+    readonly id: string;
+    readonly protocol: string;
+}
 export interface WebSocketServerDriver {
     readonly runtime: string;
-    upgrade(request: Request): Promise<WebSocketUpgradeResult>;
+    upgrade(request: Request, options: WebSocketUpgradeOptions): Promise<WebSocketUpgradeResult>;
 }
 export declare const WEBSOCKET_SERVER: import("../core/extension.js").RuntimeCapability<WebSocketServerDriver>;
 export type WebSocketCodecKind = 'json' | 'text' | 'binary';
@@ -45,13 +53,14 @@ export type WebSocketIncomingMessage<TValue> = {
 };
 export interface WebSocketBranchDefinition {
     readonly path?: string;
-    readonly responses?: Readonly<Record<string, HttpExecutionResponseDefinition>>;
     readonly routes: WebSocketRouteTree;
 }
+export interface WebSocketHandshakeDefinition extends HttpRequestHeadDefinition {
+    readonly protocols?: readonly string[];
+}
 export interface WebSocketRouteDefinition {
     readonly path: string;
-    readonly request?: Omit<HttpExecutionRequestDefinition, 'body'>;
-    readonly responses?: Readonly<Record<string, HttpExecutionResponseDefinition>>;
+    readonly handshake?: WebSocketHandshakeDefinition;
     readonly messages?: WebSocketMessageCodec;
 }
 export type WebSocketRouteTree = Readonly<Record<string, WebSocketRouteDefinition | WebSocketBranchDefinition>>;
@@ -67,24 +76,28 @@ type SendApi<TRoute extends WebSocketRouteDefinition> = TRoute['messages'] exten
 } : {} : {};
 type OpeningRequestInput<TRoute extends WebSocketRouteDefinition> = {
     readonly params: TRoute extends {
-        readonly request: {
+        readonly handshake: {
             readonly params: infer TParams extends Readonly<Record<string, StandardSchemaV1>>;
         };
     } ? {
         readonly [TName in keyof TParams]: SchemaOutput<TParams[TName]>;
     } : Readonly<Record<string, string>>;
     readonly query: TRoute extends {
-        readonly request: {
+        readonly handshake: {
             readonly query: infer TQuery extends StandardSchemaV1;
         };
     } ? SchemaOutput<TQuery> : Readonly<Record<string, string | string[]>>;
     readonly headers: TRoute extends {
-        readonly request: {
+        readonly handshake: {
             readonly headers: infer THeaders extends StandardSchemaV1;
         };
     } ? SchemaOutput<THeaders> : Headers;
 };
 export type WebSocketHandlerContext<TRoute extends WebSocketRouteDefinition = WebSocketRouteDefinition> = {
+    readonly request: Request;
+    readonly session: WebSocketSession;
+    readonly protocol: string;
+    readonly execution: ExecutionContextView;
     readonly input: OpeningRequestInput<TRoute> & IncomingApi<TRoute>;
     readonly signal: AbortSignal;
     readonly closed: Promise<WebSocketCloseInfo>;
@@ -107,8 +120,7 @@ interface CompiledWebSocketRoute {
     readonly path: string;
     readonly normalizedPath: string;
     readonly segments: readonly HttpPathSegment[];
-    readonly request?: Omit<HttpExecutionRequestDefinition, 'body'>;
-    readonly responses: Readonly<Record<string, HttpExecutionResponseDefinition>>;
+    readonly handshake?: WebSocketHandshakeDefinition;
     readonly messages?: WebSocketMessageCodec;
 }
 interface CompiledWebSocketExecution {
@@ -125,7 +137,16 @@ export interface WebSocketHostApi {
 }
 export declare const websocketExtension: import("../core/extension.js").ExecutionExtension<WebSocketImplementationDefinition<WebSocketContract<Readonly<Record<string, WebSocketBranchDefinition | WebSocketRouteDefinition>>>> & ExecutionDefinition<import("../core/extension.js").AnyExecutionExtension>, CompiledWebSocketExecution, "websocket", WebSocketHostApi, WebSocketExtensionRuntime>;
 export type WebSocketExecutionDefinition<TContract extends WebSocketContract = WebSocketContract> = WebSocketImplementationDefinition<TContract> & ExecutionDefinition<typeof websocketExtension>;
-export declare function defineWebSocketContract<const TRoutes extends WebSocketRouteTree>(routes: TRoutes): WebSocketContract<TRoutes>;
+type WebSocketV2Tree<TTree extends WebSocketRouteTree> = {
+    readonly [K in keyof TTree]: TTree[K] extends WebSocketBranchDefinition ? TTree[K] & {
+        readonly responses?: never;
+        readonly routes: WebSocketV2Tree<TTree[K]['routes']>;
+    } : TTree[K] & {
+        readonly request?: never;
+        readonly responses?: never;
+    };
+};
+export declare function defineWebSocketContract<const TRoutes extends WebSocketRouteTree>(routes: TRoutes & WebSocketV2Tree<TRoutes>): WebSocketContract<TRoutes>;
 export declare function defineWebSocketImplementation<const TContract extends WebSocketContract>(definition: {
     readonly name?: string;
     readonly contract: TContract;

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,6 +219,16 @@ 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 });
@@ -253,7 +248,7 @@ 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);
@@ -261,7 +256,7 @@ function createWebSocketRuntime(executions, driver, applicationRuntime) {
                 completePendingIngress();
                 throw error;
             }
-            const session = createSession(upgraded.connection, match.route, input, lease, handlers.get(match.executionId)?.[match.route.name], lease.run);
+            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();
@@ -281,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);
@@ -318,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 };
 }
@@ -347,7 +347,15 @@ function decodeQuery(searchParams) {
     }
     return query;
 }
-function createSession(connection, route, input, lease, handler, runInExecution) {
+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();
@@ -399,6 +407,17 @@ function createSession(connection, route, input, lease, handler, runInExecution)
     };
     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 }),
@@ -528,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.7.0",
+  "version": "0.8.1",
   "license": "MIT",
   "type": "module",
   "files": [
@@ -48,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"
@@ -75,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 {};