@loutrejs/loutre 0.6.0 → 0.8.0

package/dist/tasks/extension.js

@@ -1,5 +1,6 @@
 import { collectInjectedDependencies, defineExecution, defineExecutionExtension, provide, runInInjectionContext, token, validateSchema, } from '../core/index.js';
 import { isValidCronExpression, matchesCronTrigger } from './runtime/cron.js';
+import { match } from 'ts-pattern';
 const taskExecutionIdentityKey = Symbol.for('loutre.tasks.task-execution-identity');
 const queueDriverToken = Symbol.for('loutre.tasks.queue-driver');
 export const tasksExtension = defineExecutionExtension({
@@ -7,86 +8,78 @@ export const tasksExtension = defineExecutionExtension({
     abiVersion: '1',
     name: 'loutre:tasks',
     compile(definition) {
-        switch (definition.type) {
-            case 'task':
-                return {
-                    kind: 'execution',
-                    id: `task.${definition.name}`,
-                    executionKind: 'task.invocation',
-                    dependencies: collectInjectedDependencies({
-                        kind: 'execution',
-                        id: `task:${definition.name}`,
-                        name: definition.name,
-                    }, () => definition.factory()),
-                    capabilities: [],
-                    compiled: Object.freeze({
-                        type: 'task',
-                        taskExecutionId: definition[taskExecutionIdentityKey],
-                        name: definition.name,
-                        factory: definition.factory,
-                    }),
-                };
-            case 'cron':
-                return {
-                    kind: 'execution',
-                    id: `trigger.${definition.name}`,
-                    executionKind: 'trigger.cron',
-                    dependencies: [],
-                    capabilities: [],
-                    compiled: Object.freeze({
-                        type: 'cron',
-                        name: definition.name,
-                        expression: definition.expression,
-                        timezone: definition.timezone,
-                        overlap: definition.overlap,
-                        taskExecutionId: definition.task[taskExecutionIdentityKey],
-                        taskName: definition.task.name,
-                    }),
-                };
-            case 'fixed-delay':
-                return {
-                    kind: 'execution',
-                    id: `trigger.${definition.name}`,
-                    executionKind: 'trigger.fixed-delay',
-                    dependencies: [],
-                    capabilities: [],
-                    compiled: Object.freeze({
-                        type: 'fixed-delay',
-                        name: definition.name,
-                        delay: definition.delay,
-                        immediate: definition.immediate,
-                        taskExecutionId: definition.task[taskExecutionIdentityKey],
-                        taskName: definition.task.name,
-                    }),
-                };
-            case 'queue-consumer':
-                return {
-                    kind: 'execution',
-                    id: `trigger.${definition.name}`,
-                    executionKind: 'trigger.queue-consumer',
-                    dependencies: [queueRuntimeToken(definition.queue)],
-                    capabilities: [],
-                    compiled: Object.freeze({
-                        type: 'queue-consumer',
-                        name: definition.name,
-                        queueName: definition.queue.name,
-                        queuePayload: definition.queue.payload,
-                        queueDriver: queueRuntimeToken(definition.queue),
-                        taskExecutionId: definition.task[taskExecutionIdentityKey],
-                        taskName: definition.task.name,
-                    }),
-                };
-        }
+        return match(definition)
+            .with({ type: 'task' }, (candidate) => ({
+            kind: 'execution',
+            id: `task.${candidate.name}`,
+            executionKind: 'task.invocation',
+            dependencies: collectInjectedDependencies({
+                kind: 'execution',
+                id: `task:${candidate.name}`,
+                name: candidate.name,
+            }, () => candidate.factory()),
+            capabilities: [],
+            compiled: Object.freeze({
+                type: 'task',
+                taskExecutionId: candidate[taskExecutionIdentityKey],
+                name: candidate.name,
+                factory: candidate.factory,
+            }),
+        }))
+            .with({ type: 'cron' }, (candidate) => ({
+            kind: 'execution',
+            id: `trigger.${candidate.name}`,
+            executionKind: 'trigger.cron',
+            dependencies: [],
+            capabilities: [],
+            compiled: Object.freeze({
+                type: 'cron',
+                name: candidate.name,
+                expression: candidate.expression,
+                timezone: candidate.timezone,
+                overlap: candidate.overlap,
+                taskExecutionId: candidate.task[taskExecutionIdentityKey],
+                taskName: candidate.task.name,
+            }),
+        }))
+            .with({ type: 'fixed-delay' }, (candidate) => ({
+            kind: 'execution',
+            id: `trigger.${candidate.name}`,
+            executionKind: 'trigger.fixed-delay',
+            dependencies: [],
+            capabilities: [],
+            compiled: Object.freeze({
+                type: 'fixed-delay',
+                name: candidate.name,
+                delay: candidate.delay,
+                immediate: candidate.immediate,
+                taskExecutionId: candidate.task[taskExecutionIdentityKey],
+                taskName: candidate.task.name,
+            }),
+        }))
+            .with({ type: 'queue-consumer' }, (candidate) => ({
+            kind: 'execution',
+            id: `trigger.${candidate.name}`,
+            executionKind: 'trigger.queue-consumer',
+            dependencies: [queueRuntimeToken(candidate.queue)],
+            capabilities: [],
+            compiled: Object.freeze({
+                type: 'queue-consumer',
+                name: candidate.name,
+                queueName: candidate.queue.name,
+                queuePayload: candidate.queue.payload,
+                queueDriver: queueRuntimeToken(candidate.queue),
+                taskExecutionId: candidate.task[taskExecutionIdentityKey],
+                taskName: candidate.task.name,
+            }),
+        }))
+            .exhaustive();
     },
     references(definition) {
-        switch (definition.type) {
-            case 'task':
-                return [];
-            case 'cron':
-            case 'fixed-delay':
-            case 'queue-consumer':
-                return [definition.task];
-        }
+        return match(definition)
+            .with({ type: 'task' }, () => [])
+            .with({ type: 'cron' }, { type: 'fixed-delay' }, { type: 'queue-consumer' }, (candidate) => [candidate.task])
+            .exhaustive();
     },
     validate({ executions }) {
         const taskExecutionIds = new Set(executions.flatMap((execution) => execution.compiled.type === 'task'
@@ -133,34 +126,33 @@ export const tasksExtension = defineExecutionExtension({
     },
     projectGraph: ({ execution }) => {
         const compiled = execution.compiled;
-        switch (compiled.type) {
-            case 'task':
-                return { type: 'task', name: compiled.name };
-            case 'cron':
-                return {
-                    type: 'cron',
-                    name: compiled.name,
-                    expression: compiled.expression,
-                    timezone: compiled.timezone,
-                    overlap: compiled.overlap,
-                    task: compiled.taskName,
-                };
-            case 'fixed-delay':
-                return {
-                    type: 'fixed-delay',
-                    name: compiled.name,
-                    delay: compiled.delay,
-                    immediate: compiled.immediate,
-                    task: compiled.taskName,
-                };
-            case 'queue-consumer':
-                return {
-                    type: 'queue-consumer',
-                    name: compiled.name,
-                    queue: compiled.queueName,
-                    task: compiled.taskName,
-                };
-        }
+        return match(compiled)
+            .with({ type: 'task' }, (candidate) => ({
+            type: 'task',
+            name: candidate.name,
+        }))
+            .with({ type: 'cron' }, (candidate) => ({
+            type: 'cron',
+            name: candidate.name,
+            expression: candidate.expression,
+            timezone: candidate.timezone,
+            overlap: candidate.overlap,
+            task: candidate.taskName,
+        }))
+            .with({ type: 'fixed-delay' }, (candidate) => ({
+            type: 'fixed-delay',
+            name: candidate.name,
+            delay: candidate.delay,
+            immediate: candidate.immediate,
+            task: candidate.taskName,
+        }))
+            .with({ type: 'queue-consumer' }, (candidate) => ({
+            type: 'queue-consumer',
+            name: candidate.name,
+            queue: candidate.queueName,
+            task: candidate.taskName,
+        }))
+            .exhaustive();
     },
     host: {
         namespace: 'tasks',
@@ -238,6 +230,7 @@ export function consume(declaration) {
 }
 function createTasksRuntime(executions, applicationRuntime) {
     const runtimes = new Map();
+    const runtimeExecutionIds = new Map();
     const triggers = [];
     for (const execution of executions) {
         const compiled = execution.compiled;
@@ -254,6 +247,7 @@ function createTasksRuntime(executions, applicationRuntime) {
             resolve: (dependency) => applicationRuntime.resolve(dependency, execution.id),
         }, () => compiled.factory());
         runtimes.set(compiled.taskExecutionId, runtime);
+        runtimeExecutionIds.set(compiled.taskExecutionId, execution.id);
     }
     let triggerHandles = [];
     let triggerStartup;
@@ -261,7 +255,7 @@ function createTasksRuntime(executions, applicationRuntime) {
     let triggersStarted = false;
     let state = 'running';
     const activeInvocations = new Set();
-    const run = (taskExecutionId, taskName, ...arguments_) => {
+    const invokeTask = (taskExecutionId, taskName, arguments_) => {
         if (state !== 'running') {
             return Promise.reject(new Error(`LUTRE_TASKS_${state.toUpperCase()}`));
         }
@@ -270,18 +264,42 @@ function createTasksRuntime(executions, applicationRuntime) {
             return Promise.reject(new Error(`LUTRE_TASK_NOT_REGISTERED: ${taskName}`));
         }
         const invocation = (async () => {
-            const lease = applicationRuntime.beginExecution();
+            const executionId = runtimeExecutionIds.get(taskExecutionId) ?? taskName;
+            const hasInput = arguments_.length > 0;
+            const input = hasInput ? arguments_[0] : undefined;
+            const lease = applicationRuntime.beginExecution({
+                executionId,
+                executionKind: 'task.invocation',
+                graphNodeId: executionId,
+                name: taskName,
+            }, {
+                input,
+                invoke: (nextInput) => invokeTask(taskExecutionId, taskName, hasInput ? [nextInput] : []),
+            });
+            let result;
+            let hasResult = false;
             try {
-                return await Reflect.apply(runtime, undefined, arguments_);
+                const invoke = () => Reflect.apply(runtime, undefined, arguments_);
+                result = await (lease.run ? lease.run(invoke) : invoke());
+                hasResult = true;
+                return result;
+            }
+            catch (error) {
+                lease.fail?.(error);
+                throw error;
             }
             finally {
-                lease.complete();
+                if (hasResult)
+                    lease.complete(result);
+                else
+                    lease.complete();
             }
         })();
         activeInvocations.add(invocation);
         void invocation.then(() => activeInvocations.delete(invocation), () => activeInvocations.delete(invocation));
         return invocation;
     };
+    const run = (taskExecutionId, taskName, ...arguments_) => invokeTask(taskExecutionId, taskName, arguments_);
     const stopTriggers = () => {
         if (triggerStop)
             return triggerStop;
@@ -389,14 +407,11 @@ function createTasksRuntime(executions, applicationRuntime) {
     };
 }
 async function startTrigger(trigger, run, applicationRuntime) {
-    switch (trigger.type) {
-        case 'cron':
-            return startCronTrigger(trigger, run);
-        case 'fixed-delay':
-            return startFixedDelayTrigger(trigger, run);
-        case 'queue-consumer':
-            return startQueueTrigger(trigger, run, applicationRuntime);
-    }
+    return match(trigger)
+        .with({ type: 'cron' }, (candidate) => startCronTrigger(candidate, run))
+        .with({ type: 'fixed-delay' }, (candidate) => startFixedDelayTrigger(candidate, run))
+        .with({ type: 'queue-consumer' }, (candidate) => startQueueTrigger(candidate, run, applicationRuntime))
+        .exhaustive();
 }
 function startCronTrigger(trigger, run) {
     let stopped = false;

package/dist/websocket/driver.d.ts

@@ -0,0 +1,30 @@
+import type { WebSocketCloseInfo, WebSocketConnectionDriver, WebSocketDataMessage } from './extension.js';
+export interface WebSocketDriverChannel {
+    readonly connection: WebSocketConnectionDriver;
+    receive(message: WebSocketDataMessage): void;
+    finish(info: WebSocketCloseInfo): void;
+}
+export declare function createWebSocketDriverChannel(options: {
+    readonly protocol: string;
+    readonly send: WebSocketConnectionDriver['send'];
+    readonly close: WebSocketConnectionDriver['close'];
+    readonly terminate: WebSocketConnectionDriver['terminate'];
+}): WebSocketDriverChannel;
+export interface EventWebSocket {
+    readonly readyState: number;
+    binaryType: string;
+    send(data: string | Uint8Array): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: 'open', listener: () => void, options?: {
+        once?: boolean;
+    }): void;
+    addEventListener(type: 'message', listener: (event: {
+        data: unknown;
+    }) => void): void;
+    addEventListener(type: 'close', listener: (event: WebSocketCloseInfo) => void): void;
+    addEventListener(type: 'error', listener: () => void): void;
+}
+export declare function createEventWebSocketConnection(socket: EventWebSocket, protocol: string, options?: {
+    readonly terminate?: () => void;
+    readonly run?: <T>(operation: () => T) => Promise<T>;
+}): WebSocketConnectionDriver;

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;