@loutrejs/loutre 0.7.0 → 0.8.1

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // package manifestとのずれを避けるため、scripts/generate-version.mjsがbuild前に更新する。
-export const LOUTRE_VERSION = '0.7.0';
+export const LOUTRE_VERSION = '0.8.1';

package/dist/graph/model.js

@@ -1,4 +1,5 @@
 import { diagnostic, tokenName, } from '../core/index.js';
+import { match } from 'ts-pattern';
 export function projectApplicationModel(model) {
     const diagnostics = [...model.diagnostics];
     const projectedExecutions = new Map();
@@ -21,46 +22,42 @@ export function projectApplicationModel(model) {
     });
 }
 function projectCoreNode(node) {
-    switch (node.kind) {
-        case 'module':
-            return {
-                id: node.id,
-                kind: node.kind,
-                ...(node.source === undefined ? {} : { source: node.source }),
-                ...(node.name === undefined ? {} : { name: node.name }),
-                ...(node.description === undefined
-                    ? {}
-                    : { attributes: { description: node.description } }),
-            };
-        case 'provider':
-            return {
-                id: node.id,
-                kind: node.kind,
-                name: tokenName(node.token),
-                module: node.moduleId,
-                ...(node.source === undefined ? {} : { source: node.source }),
-                attributes: {
-                    providerKind: node.provider.kind,
-                    scope: node.provider.scope,
-                },
-            };
-        case 'lifecycle':
-            return {
-                id: node.id,
-                kind: node.kind,
-                name: node.phase,
-                module: node.moduleId,
-                ...(node.source === undefined ? {} : { source: node.source }),
-            };
-        case 'framework':
-            return {
-                id: node.id,
-                kind: node.kind,
-                name: node.name,
-                ...(node.source === undefined ? {} : { source: node.source }),
-                attributes: { frameworkKind: node.frameworkKind },
-            };
-    }
+    return match(node)
+        .with({ kind: 'module' }, (candidate) => ({
+        id: candidate.id,
+        kind: candidate.kind,
+        ...(candidate.source === undefined ? {} : { source: candidate.source }),
+        ...(candidate.name === undefined ? {} : { name: candidate.name }),
+        ...(candidate.description === undefined
+            ? {}
+            : { attributes: { description: candidate.description } }),
+    }))
+        .with({ kind: 'provider' }, (candidate) => ({
+        id: candidate.id,
+        kind: candidate.kind,
+        name: tokenName(candidate.token),
+        module: candidate.moduleId,
+        ...(candidate.source === undefined ? {} : { source: candidate.source }),
+        attributes: {
+            providerKind: candidate.provider.kind,
+            scope: candidate.provider.scope,
+        },
+    }))
+        .with({ kind: 'lifecycle' }, (candidate) => ({
+        id: candidate.id,
+        kind: candidate.kind,
+        name: candidate.phase,
+        module: candidate.moduleId,
+        ...(candidate.source === undefined ? {} : { source: candidate.source }),
+    }))
+        .with({ kind: 'framework' }, (candidate) => ({
+        id: candidate.id,
+        kind: candidate.kind,
+        name: candidate.name,
+        ...(candidate.source === undefined ? {} : { source: candidate.source }),
+        attributes: { frameworkKind: candidate.frameworkKind },
+    }))
+        .exhaustive();
 }
 function projectExtensionGroup(group, diagnostics) {
     return group.executions.map((execution) => {

package/dist/http/auth.d.ts

@@ -30,7 +30,7 @@ export interface BasicAuthDefinition<TContribution extends object, TResponse ext
 }
 export interface BasicAuthRuntime<TContribution extends object, TResponse extends string, TUnauthorizedBody> {
     authenticate(credentials: BasicAuthCredentials): TContribution | null | undefined | Promise<TContribution | null | undefined>;
-    unauthorized(): HttpAuthenticationFailure<TResponse, TUnauthorizedBody>;
+    unauthorized(): HttpAuthenticationFailure<TResponse, TUnauthorizedBody> | Response;
 }
 export declare function basicAuth<const TContribution extends object, const TResponse extends string, TUnauthorizedBody>(definition: BasicAuthDefinition<TContribution, TResponse, TUnauthorizedBody>): HttpMiddleware<TContribution, HttpMiddlewareContext, AuthenticationShortCircuit<TResponse, TUnauthorizedBody>>;
 export interface BearerAuthDefinition<TContribution extends object, TResponse extends string, TUnauthorizedBody> {
@@ -40,7 +40,7 @@ export interface BearerAuthDefinition<TContribution extends object, TResponse ex
 }
 export interface BearerAuthRuntime<TContribution extends object, TResponse extends string, TUnauthorizedBody> {
     authenticate(token: string): TContribution | null | undefined | Promise<TContribution | null | undefined>;
-    unauthorized(): HttpAuthenticationFailure<TResponse, TUnauthorizedBody>;
+    unauthorized(): HttpAuthenticationFailure<TResponse, TUnauthorizedBody> | Response;
 }
 export declare function bearerAuth<const TContribution extends object, const TResponse extends string, TUnauthorizedBody>(definition: BearerAuthDefinition<TContribution, TResponse, TUnauthorizedBody>): HttpMiddleware<TContribution, HttpMiddlewareContext, AuthenticationShortCircuit<TResponse, TUnauthorizedBody>>;
 export {};

package/dist/http/auth.js

@@ -40,6 +40,15 @@ export function bearerAuth(definition) {
     });
 }
 function authenticationFailure(failure, challenge) {
+    if (failure instanceof Response) {
+        const headers = new Headers(failure.headers);
+        headers.set('www-authenticate', challenge);
+        return new Response(failure.body, {
+            status: failure.status,
+            statusText: failure.statusText,
+            headers,
+        });
+    }
     return {
         kind: 'http-result',
         response: failure.response,

package/dist/http/client.js

@@ -1,5 +1,6 @@
 import { SchemaValidationError, validateSchema, } from '../core/index.js';
 import { parseHttpPath } from './path.js';
+import { match } from 'ts-pattern';
 export class HttpClientResponseError extends Error {
     status;
     method;
@@ -84,11 +85,10 @@ async function decodeResponse(procedure, definition, response) {
     throw new HttpClientResponseError(response.status, definition.method, definition.path, procedure, `${target} returned a response that does not match its Contract`, lastValidationError ? { cause: lastValidationError } : undefined);
 }
 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 isStandardSchema(value) {
     return typeof value === 'object' && value !== null && '~standard' in value;

package/dist/http/extension.d.ts

@@ -1,13 +1,11 @@
-import { type ExecutionDefinition, type ExecutionExtension, type ExecutionExtensionDrainContext, type GenericLayer, type RuntimeCapabilityBinding, type SchemaInput, type SchemaOutput, type StandardSchemaV1, type SourceLocation, type Type } from '../core/index.js';
+import { type ExecutionDefinition, type ExecutionContextView, type ExecutionExtension, type ExecutionExtensionDrainContext, type GenericLayer, type RuntimeCapabilityBinding, type SchemaInput, type SchemaOutput, type StandardSchemaV1, type SourceLocation, type Type } from '../core/index.js';
 import { type HttpPathSegment, type PathParamNames } from './path.js';
+import type { HttpRequestHeadDefinition } from './request-head.js';
 export interface HttpServerDriver {
     readonly runtime: string;
 }
 export declare const HTTP_SERVER: import("../core/extension.js").RuntimeCapability<HttpServerDriver>;
-export interface HttpExecutionRequestDefinition {
-    readonly params?: Readonly<Record<string, StandardSchemaV1>>;
-    readonly query?: StandardSchemaV1;
-    readonly headers?: StandardSchemaV1;
+export interface HttpExecutionRequestDefinition extends HttpRequestHeadDefinition {
     readonly body?: StandardSchemaV1;
 }
 export type HttpHeaderValue = string | readonly string[];
@@ -56,7 +54,8 @@ export interface HttpExecutionRouteDefinition {
     readonly middlewares?: readonly HttpRouteMiddleware[];
     readonly interaction?: 'unary' | 'server-stream';
 }
-type AnyHttpMiddleware = GenericLayer<any, any, HttpExecutionResult>;
+type HttpMiddlewareOutcome = HttpExecutionResult | Response;
+type AnyHttpMiddleware = GenericLayer<any, any, HttpMiddlewareOutcome>;
 type HttpRouteMiddleware = AnyHttpMiddleware | HttpValidationMiddleware;
 export interface HttpContractBranchDefinition {
     readonly path?: string;
@@ -67,7 +66,7 @@ export interface HttpContractBranchDefinition {
 export type HttpContractNodeDefinition = HttpExecutionRouteDefinition | HttpContractBranchDefinition;
 export type HttpContractRouteTree = Readonly<Record<string, HttpContractNodeDefinition>>;
 declare const httpMiddlewareShortCircuit: unique symbol;
-export type HttpMiddleware<TContribution extends object = object, TContext extends object = HttpMiddlewareContext, TShortCircuit extends HttpExecutionResult = never> = GenericLayer<TContext, TContribution, HttpExecutionResult> & {
+export type HttpMiddleware<TContribution extends object = object, TContext extends object = HttpMiddlewareContext, TShortCircuit extends HttpExecutionResult = never> = GenericLayer<TContext, TContribution, HttpMiddlewareOutcome> & {
     readonly [httpMiddlewareShortCircuit]?: TShortCircuit;
 };
 export interface HttpMiddlewareContext {
@@ -123,10 +122,13 @@ type IsHttpContractTreeInheritanceValid<TTree extends HttpContractRouteTree, TRe
 type HttpMiddlewareState<TRoute extends HttpExecutionRouteDefinition> = TRoute extends {
     readonly middlewares: infer TMiddlewares extends readonly HttpRouteMiddleware[];
 } ? UnionToIntersection<MiddlewareContribution<TMiddlewares[number]>> : {};
+declare const httpContractBrand: unique symbol;
 export interface HttpContract<TRoutes extends Readonly<Record<string, HttpExecutionRouteDefinition>> = Readonly<Record<string, HttpExecutionRouteDefinition>>> {
     readonly kind: 'http-contract';
     readonly routes: TRoutes;
+    readonly [httpContractBrand]: true;
 }
+export declare function isHttpContract(value: unknown): value is HttpContract;
 type RequestValue<TRequest extends HttpExecutionRequestDefinition | undefined, TPart extends keyof HttpExecutionRequestDefinition, TFallback> = TRequest extends HttpExecutionRequestDefinition ? TRequest[TPart] extends StandardSchemaV1 ? SchemaOutput<TRequest[TPart]> : TFallback : TFallback;
 type RawHttpQuery = Readonly<Record<string, string | readonly string[] | undefined>>;
 type RawHttpRequestHeaders = Readonly<Record<string, string | undefined>>;
@@ -198,6 +200,28 @@ export interface HttpImplementationDefinition<TContract extends HttpContract = H
     readonly contract: TContract;
     readonly factory: () => HttpHandlers<TContract>;
 }
+export interface HttpRawRouteDefinition {
+    readonly method: string;
+    readonly path: string;
+    readonly middlewares?: readonly AnyHttpMiddleware[];
+    readonly protocol?: string;
+}
+export interface HttpRawExecutionContext<TState = Readonly<Record<string, unknown>>> {
+    readonly request: Request;
+    readonly signal: AbortSignal;
+    readonly state: Readonly<TState>;
+    readonly execution: ExecutionContextView;
+}
+type RawMiddlewareState<TMiddlewares extends readonly AnyHttpMiddleware[]> = UnionToIntersection<MiddlewareContribution<TMiddlewares[number]>> & object;
+export interface HttpRawDefinition<TMiddlewares extends readonly AnyHttpMiddleware[] = readonly AnyHttpMiddleware[]> {
+    readonly name?: string;
+    readonly route: HttpRawRouteDefinition & {
+        readonly middlewares?: TMiddlewares;
+    };
+    readonly factory: () => (context: HttpRawExecutionContext<RawMiddlewareState<TMiddlewares>>) => Response | Promise<Response>;
+}
+export type HttpRawExecutionDefinition = HttpRawDefinition & ExecutionDefinition<typeof httpExecutionExtension>;
+export declare function defineHttpRaw<const TMiddlewares extends readonly AnyHttpMiddleware[] = readonly []>(definition: HttpRawDefinition<TMiddlewares>): HttpRawDefinition<TMiddlewares> & ExecutionDefinition<typeof httpExecutionExtension>;
 interface CompiledHttpRoute {
     readonly name: string;
     readonly method: string;
@@ -207,10 +231,12 @@ interface CompiledHttpRoute {
     readonly definition: HttpExecutionRouteDefinition;
     readonly middlewares: readonly AnyHttpMiddleware[];
     readonly source?: SourceLocation;
+    readonly raw?: boolean;
+    readonly protocol?: string;
 }
 interface CompiledHttpExecution {
     readonly routes: readonly CompiledHttpRoute[];
-    readonly factory: () => Record<string, (context: HttpExecutionContext) => HttpExecutionResult | Promise<HttpExecutionResult>>;
+    readonly factory: () => Record<string, (context: HttpExecutionContext) => HttpMiddlewareOutcome | Promise<HttpMiddlewareOutcome>>;
 }
 export interface HttpExtensionRuntime {
     fetch(request: Request): Promise<Response>;
@@ -220,7 +246,7 @@ export interface HttpHostApi {
     fetch(request: Request): Promise<Response>;
 }
 declare const httpExecutionExtensionIdentity: unique symbol;
-export declare const httpExecutionExtension: ExecutionExtension<HttpImplementationDefinition & ExecutionDefinition, CompiledHttpExecution, 'http', HttpHostApi, HttpExtensionRuntime> & {
+export declare const httpExecutionExtension: ExecutionExtension<(HttpImplementationDefinition | HttpRawDefinition) & ExecutionDefinition, CompiledHttpExecution, 'http', HttpHostApi, HttpExtensionRuntime> & {
     readonly [httpExecutionExtensionIdentity]: true;
 };
 export type HttpExecutionDefinition<TContract extends HttpContract = HttpContract> = HttpImplementationDefinition<TContract> & ExecutionDefinition<typeof httpExecutionExtension>;
@@ -328,6 +354,7 @@ export declare const validate: Readonly<{
     }>;
 }>;
 export declare const executionHttp: Readonly<{
+    raw: typeof defineHttpRaw;
     contract: typeof defineHttpContract;
     implementation: typeof defineHttpImplementation;
     middleware: typeof defineHttpMiddleware;
@@ -338,7 +365,7 @@ export declare const executionHttp: Readonly<{
         }>;
     }>;
     error: typeof httpError;
-    extension: ExecutionExtension<HttpImplementationDefinition<HttpContract<Readonly<Record<string, HttpExecutionRouteDefinition>>>> & ExecutionDefinition<import("../core/extension.js").AnyExecutionExtension>, CompiledHttpExecution, "http", HttpHostApi, HttpExtensionRuntime> & {
+    extension: ExecutionExtension<(HttpImplementationDefinition<HttpContract<Readonly<Record<string, HttpExecutionRouteDefinition>>>> | HttpRawDefinition<readonly AnyHttpMiddleware[]>) & ExecutionDefinition<import("../core/extension.js").AnyExecutionExtension>, CompiledHttpExecution, "http", HttpHostApi, HttpExtensionRuntime> & {
         readonly [httpExecutionExtensionIdentity]: true;
     };
     serverCapability: import("../core/extension.js").RuntimeCapability<HttpServerDriver>;

package/dist/http/extension.js

@@ -1,18 +1,35 @@
 import { collectInjectedDependencies, getSourceLocation, inheritSourceLocation, composeLayers, defineExecution, defineExecutionExtension, defineLayer, runInInjectionContext, runtimeCapability, SchemaValidationError, validateSchema, } from '../core/index.js';
 import { createCorsActualResponseHeaders, createCorsPreflightResponseHeaders, } from './cors-internal.js';
 import { assertValidHttpMethod, compareHttpPathSpecificity, createHttpDispatchKey, HttpPathDecodeError, matchHttpPath, parseHttpPath, } from './path.js';
+import { findHttpRouteConflicts } from './route-validation.js';
 import { IngressGate } from '../runtime/ingress-gate.js';
 import { AsyncIteratorCleanupDeadlineError, AsyncIteratorLifecycle, } from '../runtime/async-iterator-lifecycle.js';
 import { decodeBody, decodeQuery, HttpInputDecodeError, HttpInputValidationError, HttpUnsupportedMediaTypeError, validatedContentType, validateRequestHeaders, } from './runtime/request.js';
 import { applyFrameworkHeadersToResponse, applyFrameworkResponseHeaders, applyResponseHeaders, isResponseHeadersWithDefaults, isStandardSchema, mergeResponseHeaders, responseHeadersDefaults, responseHeadersSchema, validateResponseHeaders, } from './runtime/response.js';
+import { match as patternMatch } from 'ts-pattern';
 export const HTTP_SERVER = runtimeCapability('http.server');
+const httpContractBrand = Symbol.for('loutre.http-contract');
+export function isHttpContract(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const candidate = value;
+    return (candidate.kind === 'http-contract' &&
+        candidate[httpContractBrand] === true &&
+        typeof candidate.routes === 'object' &&
+        candidate.routes !== null);
+}
+export function defineHttpRaw(definition) {
+    return defineExecution(httpExecutionExtension, { ...definition, raw: true });
+}
 export const httpExecutionExtension = defineExecutionExtension({
     kind: 'execution-extension',
     abiVersion: '1',
     name: 'loutre:http',
     compile(definition, context) {
-        const contractSource = getSourceLocation(definition.contract);
-        const routes = Object.entries(definition.contract.routes).map(([name, route]) => compileHttpRoute(name, route, contractSource));
+        const raw = 'route' in definition;
+        const routes = raw
+            ? [compileRawRoute(definition.route)]
+            : Object.entries(definition.contract.routes).map(([name, route]) => compileHttpRoute(name, route, getSourceLocation(definition.contract)));
         const id = definition.name || `${context.moduleId}.http.${context.definitionIndex}`;
         const dependencies = new Set(collectInjectedDependencies({
             kind: 'execution',
@@ -43,25 +60,22 @@ export const httpExecutionExtension = defineExecutionExtension({
             ],
             compiled: Object.freeze({
                 routes: Object.freeze(routes),
-                factory: definition.factory,
+                factory: (raw
+                    ? () => ({ raw: definition.factory() })
+                    : definition.factory),
             }),
         };
     },
     validate({ executions }) {
-        const dispatches = new Map();
-        return executions.flatMap((execution) => execution.compiled.routes.flatMap((route) => {
-            const owner = dispatches.get(route.dispatch);
-            if (owner) {
-                return [
-                    {
-                        code: 'LUTRE_HTTP_DUPLICATE_ROUTE',
-                        message: `${route.method} ${route.path} conflicts with ${owner}.`,
-                        path: execution.id,
-                    },
-                ];
-            }
-            dispatches.set(route.dispatch, execution.id);
-            return [];
+        const routes = executions.flatMap((execution) => execution.compiled.routes.map((route) => ({
+            method: route.method,
+            path: route.path,
+            owner: execution.id,
+        })));
+        return findHttpRouteConflicts(routes).map(({ existing, route }) => ({
+            code: 'LUTRE_HTTP_DUPLICATE_ROUTE',
+            message: `${route.method} ${route.path} conflicts with ${existing.owner}.`,
+            path: route.owner,
         }));
     },
     createRuntime(context) {
@@ -81,10 +95,16 @@ export const httpExecutionExtension = defineExecutionExtension({
                     ? {}
                     : { source: getSourceLocation(middleware) }),
             })),
-            responses: Object.fromEntries(Object.entries(route.definition.responses).map(([name, response]) => [
-                name,
-                { status: response.status },
-            ])),
+            ...(route.raw
+                ? {
+                    raw: true,
+                    ...(route.protocol === undefined
+                        ? {}
+                        : { protocol: route.protocol }),
+                }
+                : {
+                    responses: Object.fromEntries(Object.entries(route.definition.responses).map(([name, response]) => [name, { status: response.status }])),
+                }),
         })),
     }),
     host: {
@@ -101,12 +121,14 @@ export function httpError(definition, map) {
 }
 export function defineHttpContract(routes) {
     const resolvedRoutes = resolveHttpContractRoutes(routes);
-    for (const [name, route] of Object.entries(resolvedRoutes)) {
-        compileHttpRoute(name, route);
-    }
+    const canonicalRoutes = Object.fromEntries(Object.entries(resolvedRoutes).map(([name, route]) => [
+        name,
+        compileHttpRoute(name, route).definition,
+    ]));
     return Object.freeze({
         kind: 'http-contract',
-        routes: Object.freeze(resolvedRoutes),
+        [httpContractBrand]: true,
+        routes: Object.freeze(canonicalRoutes),
     });
 }
 function resolveHttpContractRoutes(tree) {
@@ -186,6 +208,7 @@ export const validate = Object.freeze({
     body: bodyValidation,
 });
 export const executionHttp = Object.freeze({
+    raw: defineHttpRaw,
     contract: defineHttpContract,
     implementation: defineHttpImplementation,
     middleware: defineHttpMiddleware,
@@ -203,7 +226,29 @@ export function withHttpFrameworkHeaders(result, headers) {
         [httpFrameworkHeaders]: { ...current, ...headers },
     };
 }
+function compileRawRoute(route) {
+    if (route.method !== '*')
+        assertValidHttpMethod(route.method);
+    const segments = parseHttpPath(route.path);
+    return Object.freeze({
+        name: 'raw',
+        method: route.method.toUpperCase(),
+        path: route.path,
+        segments,
+        dispatch: createHttpDispatchKey(route.method, segments),
+        definition: Object.freeze({
+            method: route.method,
+            path: route.path,
+            responses: Object.freeze({}),
+        }),
+        middlewares: Object.freeze([...(route.middlewares ?? [])]),
+        raw: true,
+        ...(route.protocol === undefined ? {} : { protocol: route.protocol }),
+    });
+}
 function compileHttpRoute(name, route, routeSourceFallback) {
+    if (route.method === '*')
+        throw new TypeError('method: *はhttp.raw()でのみ利用できます。');
     assertValidHttpMethod(route.method);
     const segments = parseHttpPath(route.path);
     assertValidHttpRouteDefinition(route, segments);
@@ -281,15 +326,15 @@ function compileHttpMiddlewares(route) {
     return Object.freeze(compiled);
 }
 function compileHttpValidationMiddleware(middleware, route) {
-    switch (middleware.part) {
-        case 'body': {
-            const schema = route.request?.body;
-            if (!schema) {
-                throw new TypeError(`HTTP ${route.method} ${route.path} uses validate.body but declares no request body.`);
-            }
-            return createBodyValidationMiddleware(schema);
+    return patternMatch(middleware)
+        .with({ part: 'body' }, () => {
+        const schema = route.request?.body;
+        if (!schema) {
+            throw new TypeError(`HTTP ${route.method} ${route.path} uses validate.body but declares no request body.`);
         }
-    }
+        return createBodyValidationMiddleware(schema);
+    })
+        .exhaustive();
 }
 function createBodyValidationMiddleware(schema) {
     return defineLayer({
@@ -562,14 +607,33 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
                             kind: 'http.handler',
                             name: handlerName,
                             graphNodeId: match.executionId,
-                        }, {
-                            input: middlewareContext.input,
-                            invoke: (input) => replayHttpHandler(applicationRuntime, handler, match, input, middlewareContext.state),
-                        });
+                        }, match.route.raw
+                            ? undefined
+                            : {
+                                input: middlewareContext.input,
+                                invoke: (input) => replayHttpHandler(applicationRuntime, handler, match, input, middlewareContext.state),
+                            });
                         const invoke = () => handler({
+                            ...(match.route.raw
+                                ? {
+                                    request,
+                                    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: middlewareContext.input,
                             response: middlewareContext.response,
-                            signal: middlewareContext.signal,
+                            signal: match.route.raw
+                                ? request.signal
+                                : middlewareContext.signal,
                             state: middlewareContext.state,
                         });
                         let result;
@@ -596,6 +660,20 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
                 const result = await (lease.run ? lease.run(dispatch) : dispatch());
                 executionResult = result;
                 hasExecutionResult = true;
+                if (result instanceof Response) {
+                    if (result.body) {
+                        const stream = createLeasedReadableStream(result.body, lease.signal, finishExecution);
+                        adoptResponseStream(stream);
+                        return complete(new Response(stream.stream, {
+                            status: result.status,
+                            statusText: result.statusText,
+                            headers: result.headers,
+                        }));
+                    }
+                    return complete(result);
+                }
+                if (match.route.raw)
+                    throw new TypeError('Raw handlerとmiddlewareはResponseを返す必要があります。');
                 const finalized = await finalizeHttpResult(match.route.definition, result, lease.signal, finishExecution);
                 if (finalized.streamControl)
                     adoptResponseStream(finalized.streamControl);
@@ -634,7 +712,7 @@ function createHttpExtensionRuntime(executions, applicationRuntime) {
 }
 function findRuntimeHttpRoute(routes, method, pathname) {
     for (const candidate of routes) {
-        if (candidate.route.method !== method)
+        if (candidate.route.method !== method && candidate.route.method !== '*')
             continue;
         const params = matchHttpPath(candidate.route.segments, pathname);
         if (!params)

package/dist/http/index.d.ts

@@ -4,7 +4,8 @@ export { cors } from './cors.js';
 export type { CorsLayerDescriptor, CorsOptions, CorsOrigin } from './cors.js';
 export { basicAuth, bearerAuth } from './auth.js';
 export type { BasicAuthContext, BasicAuthCredentials, BasicAuthDefinition, BasicAuthUnauthorized, BasicAuthRuntime, BearerAuthContext, BearerAuthDefinition, BearerAuthRuntime, BearerAuthUnauthorized, HttpAuthenticationFailure, } from './auth.js';
-export { bindHttpServer, defineHttpContract, defineHttpImplementation, defineHttpMiddleware, httpError, executionHttp as http, httpExecutionExtension, HTTP_SERVER, validate, } from './extension.js';
-export type { HttpContract, HttpContractBranchDefinition, HttpContractNodeDefinition, HttpContractRouteTree, HttpExecutionContext, HttpExecutionDefinition, HttpExecutionRequestDefinition, HttpExecutionResponseDefinition, HttpExecutionResult, HttpExecutionRouteDefinition, HttpErrorMapping, HttpErrorMatcher, HttpExtensionRuntime, HttpHandlers, HttpHeaderValue, HttpHeaders, HttpHostApi, HttpImplementationDefinition, HttpMiddleware, HttpMiddlewareContext, HttpResponseHeadersDefinition, HttpResponseResult, HttpResponseHeadersWithDefaults, HttpServerDriver, HttpValidationMiddleware, HttpValidationPart, ResolvedHttpContractRoutes, } from './extension.js';
+export { bindHttpServer, defineHttpContract, defineHttpImplementation, defineHttpMiddleware, defineHttpRaw, httpError, executionHttp as http, httpExecutionExtension, isHttpContract, HTTP_SERVER, validate, } from './extension.js';
+export type { HttpRawDefinition, HttpRawRouteDefinition, HttpRawExecutionContext, HttpRawExecutionDefinition, HttpContract, HttpContractBranchDefinition, HttpContractNodeDefinition, HttpContractRouteTree, HttpExecutionContext, HttpExecutionDefinition, HttpExecutionRequestDefinition, HttpExecutionResponseDefinition, HttpExecutionResult, HttpExecutionRouteDefinition, HttpErrorMapping, HttpErrorMatcher, HttpExtensionRuntime, HttpHandlers, HttpHeaderValue, HttpHeaders, HttpHostApi, HttpImplementationDefinition, HttpMiddleware, HttpMiddlewareContext, HttpResponseHeadersDefinition, HttpResponseResult, HttpResponseHeadersWithDefaults, HttpServerDriver, HttpValidationMiddleware, HttpValidationPart, ResolvedHttpContractRoutes, } from './extension.js';
 export { compareHttpPathSpecificity, HttpPathDecodeError, matchHttpPath, normalizeHttpPath, parseHttpPath, } from './path.js';
 export type { HttpPathSegment, PathParamNames } from './path.js';
+export type { HttpRequestHeadDefinition } from './request-head.js';

package/dist/http/index.js

@@ -1,5 +1,5 @@
 export { createHttpClient, fetchHttpTransport, HttpClientResponseError, } from './client.js';
 export { cors } from './cors.js';
 export { basicAuth, bearerAuth } from './auth.js';
-export { bindHttpServer, defineHttpContract, defineHttpImplementation, defineHttpMiddleware, httpError, executionHttp as http, httpExecutionExtension, HTTP_SERVER, validate, } from './extension.js';
+export { bindHttpServer, defineHttpContract, defineHttpImplementation, defineHttpMiddleware, defineHttpRaw, httpError, executionHttp as http, httpExecutionExtension, isHttpContract, HTTP_SERVER, validate, } from './extension.js';
 export { compareHttpPathSpecificity, HttpPathDecodeError, matchHttpPath, normalizeHttpPath, parseHttpPath, } from './path.js';

package/dist/http/openapi.d.ts

@@ -1,5 +1,5 @@
 import { type ApplicationModel } from '../core/index.js';
-import { type HttpExecutionResponseDefinition, type HttpExecutionRouteDefinition } from './extension.js';
+import { type HttpContract, type HttpExecutionResponseDefinition, type HttpExecutionRouteDefinition } from './extension.js';
 export interface OpenApiInfo {
     readonly title: string;
     readonly version: string;
@@ -37,7 +37,6 @@ export interface HttpOperationTarget {
     };
     readonly procedure: string;
 }
-export declare function generateOpenApi(source: ApplicationModel | {
-    readonly model: ApplicationModel;
-}, options: GenerateOpenApiOptions): OpenApiDocument;
+export type OpenApiSource = ApplicationModel | HttpContract;
+export declare function generateOpenApi(source: OpenApiSource, options: GenerateOpenApiOptions): OpenApiDocument;
 export {};