@loutrejs/loutre 0.7.0 → 0.8.0

package/dist/http/openapi.js

@@ -1,5 +1,7 @@
 import { supportsJsonSchema, assertValidApplicationModel, } from '../core/index.js';
-import { httpExecutionExtension, } from './extension.js';
+import { httpExecutionExtension, isHttpContract, } from './extension.js';
+import { findHttpRouteConflicts } from './route-validation.js';
+import { match } from 'ts-pattern';
 const FIXED_METHODS = new Set([
     'get',
     'put',
@@ -12,24 +14,11 @@ const FIXED_METHODS = new Set([
     'query',
 ]);
 export function generateOpenApi(source, options) {
-    const model = 'model' in source ? source.model : source;
-    assertValidApplicationModel(model);
     const registry = new SchemaRegistry();
     const paths = {};
     const operationIds = new Set();
-    const http = model.extensions.get(httpExecutionExtension);
-    for (const execution of http?.executions ?? []) {
-        for (const route of execution.compiled.routes) {
-            const target = {
-                procedure: route.name,
-                definition: {
-                    ...route.definition,
-                    method: route.method,
-                    path: route.path,
-                },
-            };
-            attachOperation(paths, target.definition, createOperation(target, registry, operationIds, options.operationId));
-        }
+    for (const target of httpOperationTargets(source)) {
+        attachOperation(paths, target.definition, createOperation(target, registry, operationIds, options.operationId));
     }
     const schemas = registry.components();
     return {
@@ -40,6 +29,37 @@ export function generateOpenApi(source, options) {
         ...(Object.keys(schemas).length === 0 ? {} : { components: { schemas } }),
     };
 }
+function httpOperationTargets(source) {
+    if (source.kind === 'http-contract') {
+        if (!isHttpContract(source)) {
+            throw openApiError('LUTRE_OPENAPI_SOURCE_001', 'HttpContract source must be created by http.contract().');
+        }
+        const routes = Object.entries(source.routes).map(([procedure, definition]) => ({ procedure, definition }));
+        const [conflict] = findHttpRouteConflicts(routes.map(({ definition }) => definition));
+        if (conflict) {
+            throw openApiError('LUTRE_OPENAPI_OPERATION_001', `Duplicate OpenAPI operation: ${conflict.route.method.toUpperCase()} ${conflict.route.path} conflicts with ${conflict.existing.method.toUpperCase()} ${conflict.existing.path}`);
+        }
+        return routes.map(({ procedure, definition }) => ({
+            procedure,
+            definition: {
+                ...definition,
+                method: definition.method.toUpperCase(),
+            },
+        }));
+    }
+    assertValidApplicationModel(source);
+    const http = source.extensions.get(httpExecutionExtension);
+    return (http?.executions ?? []).flatMap((execution) => execution.compiled.routes
+        .filter((route) => !route.raw)
+        .map((route) => ({
+        procedure: route.name,
+        definition: {
+            ...route.definition,
+            method: route.method,
+            path: route.path,
+        },
+    })));
+}
 function createOperation(target, registry, operationIds, resolveOperationId) {
     const definition = target.definition;
     const operationId = resolveOperationId?.({
@@ -244,18 +264,17 @@ function mergeResponseHeaders(entries, registry, target) {
     ]));
 }
 function responseHeadersSchema(headers) {
-    if (isStandardSchema(headers))
-        return headers;
-    if (isResponseHeadersWithDefaults(headers))
-        return headers.schema;
-    return undefined;
+    return match(headers)
+        .when(isStandardSchema, (schema) => schema)
+        .when(isResponseHeadersWithDefaults, (definition) => definition.schema)
+        .otherwise(() => undefined);
 }
 function responseHeadersDefaults(headers) {
-    if (headers === undefined || isStandardSchema(headers))
-        return undefined;
-    if (isResponseHeadersWithDefaults(headers))
-        return headers.defaults;
-    return headers;
+    return match(headers)
+        .with(undefined, () => undefined)
+        .when(isStandardSchema, () => undefined)
+        .when(isResponseHeadersWithDefaults, (definition) => definition.defaults)
+        .otherwise((definition) => definition);
 }
 function isStandardSchema(value) {
     return typeof value === 'object' && value !== null && '~standard' in value;

package/dist/http/request-head.d.ts

@@ -0,0 +1,6 @@
+import type { StandardSchemaV1 } from '../core/index.js';
+export interface HttpRequestHeadDefinition {
+    readonly params?: Readonly<Record<string, StandardSchemaV1>>;
+    readonly query?: StandardSchemaV1;
+    readonly headers?: StandardSchemaV1;
+}

package/dist/http/request-head.js

@@ -0,0 +1 @@
+export {};

package/dist/http/route-validation.d.ts

@@ -0,0 +1,9 @@
+export interface HttpRouteDescriptor {
+    readonly method: string;
+    readonly path: string;
+}
+export interface HttpRouteConflict<TRoute extends HttpRouteDescriptor> {
+    readonly existing: TRoute;
+    readonly route: TRoute;
+}
+export declare function findHttpRouteConflicts<TRoute extends HttpRouteDescriptor>(routes: readonly TRoute[]): readonly HttpRouteConflict<TRoute>[];

package/dist/http/route-validation.js

@@ -0,0 +1,18 @@
+import { createHttpDispatchKey, parseHttpPath } from './path.js';
+export function findHttpRouteConflicts(routes) {
+    const dispatches = new Map();
+    const conflicts = [];
+    for (const route of routes) {
+        const dispatch = createHttpDispatchKey(route.method, parseHttpPath(route.path));
+        const existing = dispatches.get(dispatch) ??
+            [...dispatches.values()].find((candidate) => (route.method === '*' || candidate.method === '*') &&
+                createHttpDispatchKey('*', parseHttpPath(candidate.path)) ===
+                    createHttpDispatchKey('*', parseHttpPath(route.path)));
+        if (existing) {
+            conflicts.push({ existing, route });
+            continue;
+        }
+        dispatches.set(dispatch, route);
+    }
+    return conflicts;
+}

package/dist/http/runtime/response.js

@@ -1,4 +1,5 @@
 import { validateSchema } from '../../core/index.js';
+import { match } from 'ts-pattern';
 export async function validateResponseHeaders(schema, headers) {
     if (!schema) {
         if (headers !== undefined) {
@@ -15,18 +16,17 @@ export async function validateResponseHeaders(schema, headers) {
     return validated;
 }
 export function responseHeadersSchema(headers) {
-    if (isStandardSchema(headers))
-        return headers;
-    if (isResponseHeadersWithDefaults(headers))
-        return headers.schema;
-    return undefined;
+    return match(headers)
+        .when(isStandardSchema, (schema) => schema)
+        .when(isResponseHeadersWithDefaults, (definition) => definition.schema)
+        .otherwise(() => undefined);
 }
 export function responseHeadersDefaults(headers) {
-    if (headers === undefined || isStandardSchema(headers))
-        return undefined;
-    if (isResponseHeadersWithDefaults(headers))
-        return headers.defaults;
-    return headers;
+    return match(headers)
+        .with(undefined, () => undefined)
+        .when(isStandardSchema, () => undefined)
+        .when(isResponseHeadersWithDefaults, (definition) => definition.defaults)
+        .otherwise((definition) => definition);
 }
 export function isStandardSchema(value) {
     return typeof value === 'object' && value !== null && '~standard' in value;

package/dist/runtime/di.js

@@ -1,5 +1,6 @@
 import { isArgsClass, isEnvClass, runInInjectionContext, tokenName, } from '../core/index.js';
 import { Logger } from './logger.js';
+import { match } from 'ts-pattern';
 export class DependencyResolutionError extends Error {
     constructor(message) {
         super(message);
@@ -133,49 +134,49 @@ export class Container {
     }
     #create(provider, lineage) {
         try {
-            switch (provider.kind) {
-                case 'value': {
-                    this.#hooks.created?.(provider, provider.useValue);
-                    return provider.useValue;
+            return match(provider)
+                .with({ kind: 'value' }, (candidate) => {
+                this.#hooks.created?.(candidate, candidate.useValue);
+                return candidate.useValue;
+            })
+                .with({ kind: 'environment' }, (candidate) => {
+                if (this.#environment.has(candidate.provide)) {
+                    return this.#environment.get(candidate.provide);
                 }
-                case 'environment': {
-                    if (this.#environment.has(provider.provide)) {
-                        return this.#environment.get(provider.provide);
-                    }
-                    throw new DependencyResolutionError(`LUTRE_ENV_005: Environment ${provider.provide.name} requires a runtime Environment source before Application initialization.`);
+                throw new DependencyResolutionError(`LUTRE_ENV_005: Environment ${candidate.provide.name} requires a runtime Environment source before Application initialization.`);
+            })
+                .with({ kind: 'arguments' }, (candidate) => {
+                if (this.#arguments.has(candidate.provide)) {
+                    return this.#arguments.get(candidate.provide);
                 }
-                case 'arguments': {
-                    if (this.#arguments.has(provider.provide)) {
-                        return this.#arguments.get(provider.provide);
-                    }
-                    throw new DependencyResolutionError(`LUTRE_ARGS_005: Arguments ${provider.provide.name} requires runtime Arguments before Application initialization.`);
+                throw new DependencyResolutionError(`LUTRE_ARGS_005: Arguments ${candidate.provide.name} requires runtime Arguments before Application initialization.`);
+            })
+                .with({ kind: 'class' }, (candidate) => {
+                const value = this.#instantiate(candidate.useClass, lineage);
+                this.#hooks.created?.(candidate, value);
+                return value;
+            })
+                .with({ kind: 'factory' }, (candidate) => {
+                const dependencies = candidate.inject.map((token) => this.#resolve(token, tokenName(candidate.provide), lineage));
+                const value = candidate.useFactory(...dependencies);
+                if (isThenable(value)) {
+                    throw new DependencyResolutionError('LUTRE_DI_ASYNC_FACTORY: Async factory providers are not supported. Move asynchronous resource initialization to application lifecycle.');
                 }
-                case 'class': {
-                    const value = this.#instantiate(provider.useClass, lineage);
-                    this.#hooks.created?.(provider, value);
-                    return value;
+                this.#hooks.created?.(candidate, value);
+                return value;
+            })
+                .with({ kind: 'conditional' }, (candidate) => {
+                const input = this.#resolve(candidate.select.contract, tokenName(candidate.provide), lineage);
+                const selected = input[candidate.select.key];
+                const implementation = candidate.mapping[selected];
+                if (!implementation) {
+                    throw new DependencyResolutionError(`No conditional Provider matches ${candidate.select.key}=${String(selected)}`);
                 }
-                case 'factory': {
-                    const dependencies = provider.inject.map((token) => this.#resolve(token, tokenName(provider.provide), lineage));
-                    const value = provider.useFactory(...dependencies);
-                    if (isThenable(value)) {
-                        throw new DependencyResolutionError('LUTRE_DI_ASYNC_FACTORY: Async factory providers are not supported. Move asynchronous resource initialization to application lifecycle.');
-                    }
-                    this.#hooks.created?.(provider, value);
-                    return value;
-                }
-                case 'conditional': {
-                    const input = this.#resolve(provider.select.contract, tokenName(provider.provide), lineage);
-                    const selected = input[provider.select.key];
-                    const implementation = provider.mapping[selected];
-                    if (!implementation) {
-                        throw new DependencyResolutionError(`No conditional Provider matches ${provider.select.key}=${String(selected)}`);
-                    }
-                    const value = this.#instantiate(implementation, lineage);
-                    this.#hooks.created?.(provider, value);
-                    return value;
-                }
-            }
+                const value = this.#instantiate(implementation, lineage);
+                this.#hooks.created?.(candidate, value);
+                return value;
+            })
+                .exhaustive();
         }
         catch (error) {
             if (provider.scope === 'application') {

package/dist/runtime/engine.d.ts

@@ -1,3 +1,3 @@
-export type RuntimeEngine = 'node' | 'bun' | 'deno' | 'cloudflare-workers' | 'aws-lambda' | 'electron' | 'unknown';
+export type RuntimeEngine = 'node' | 'bun' | 'cloudflare-workers' | 'aws-lambda' | 'electron' | 'unknown';
 export declare function detectRuntimeEngine(): RuntimeEngine;
 export declare function assertRuntimeEngine(expected: Exclude<RuntimeEngine, 'unknown'>): void;

package/dist/runtime/engine.js

@@ -1,7 +1,6 @@
 const runtimeLabels = {
     node: 'Node.js',
     bun: 'Bun',
-    deno: 'Deno',
     'cloudflare-workers': 'Cloudflare Workers',
     'aws-lambda': 'AWS Lambda',
     electron: 'Electron',
@@ -14,7 +13,7 @@ export function detectRuntimeEngine() {
         return 'bun';
     }
     if (globals.Deno !== undefined)
-        return 'deno';
+        return 'unknown';
     if (globals.navigator?.userAgent === 'Cloudflare-Workers' ||
         globals.WebSocketPair !== undefined) {
         return 'cloudflare-workers';

package/dist/runtime/node-capabilities.d.ts

@@ -1,4 +1,4 @@
-/** CLIが`@loutrejs/node`へ依存するとBun/DenoでもNode.js専用moduleを評価するため、Capability metadataだけをruntime-neutral側へ分離する。 */
+/** CLIが`@loutrejs/node`へ依存するとBunでもNode.js専用moduleを評価するため、Capability metadataだけをruntime-neutral側へ分離する。 */
 export declare const nodeRuntimeSupport: {
     readonly runtime: 'node';
     readonly capabilities: Set<string>;

package/dist/runtime/node-capabilities.js

@@ -1,8 +1,9 @@
-/** CLIが`@loutrejs/node`へ依存するとBun/DenoでもNode.js専用moduleを評価するため、Capability metadataだけをruntime-neutral側へ分離する。 */
+/** CLIが`@loutrejs/node`へ依存するとBunでもNode.js専用moduleを評価するため、Capability metadataだけをruntime-neutral側へ分離する。 */
 export const nodeRuntimeSupport = {
     runtime: 'node',
     capabilities: new Set([
         'http.server',
+        'websocket.server',
         'http.request.streaming',
         'http.response.streaming',
         'stream.readable',

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',
@@ -415,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;