@loutrejs/loutre 0.6.0 → 0.8.0

package/dist/devtools/values.js

@@ -0,0 +1,172 @@
+import { match } from 'ts-pattern';
+const defaultMaxValueBytes = 64 * 1024;
+const defaultMaxDepth = 8;
+export function previewDevtoolsValue(value, options = {}) {
+    const maxValueBytes = options.maxValueBytes ?? defaultMaxValueBytes;
+    const maxDepth = options.maxDepth ?? defaultMaxDepth;
+    const redactions = new Set((options.redact ?? []).map((entry) => entry.trim().toLowerCase()));
+    let redacted = false;
+    let truncated = false;
+    const seen = new WeakSet();
+    const encode = (current, depth, path) => {
+        if (depth > maxDepth) {
+            truncated = true;
+            return '[Truncated]';
+        }
+        if (current === null)
+            return null;
+        switch (typeof current) {
+            case 'boolean':
+            case 'number':
+            case 'string':
+                return current;
+            case 'undefined':
+                return { $type: 'undefined' };
+            case 'bigint':
+                return { $type: 'bigint', value: current.toString() };
+            case 'function':
+            case 'symbol':
+                truncated = true;
+                return `[${typeof current}]`;
+            case 'object':
+                break;
+        }
+        if (current instanceof Date) {
+            return { $type: 'date', value: current.toISOString() };
+        }
+        if (current instanceof Uint8Array) {
+            return { $type: 'bytes', base64: bytesToBase64(current) };
+        }
+        if (seen.has(current)) {
+            truncated = true;
+            return '[Circular]';
+        }
+        seen.add(current);
+        try {
+            if (Array.isArray(current)) {
+                const output = [];
+                const descriptors = Object.getOwnPropertyDescriptors(current);
+                for (let index = 0; index < current.length; index += 1) {
+                    const descriptor = descriptors[String(index)];
+                    if (!descriptor) {
+                        output.length = index + 1;
+                        continue;
+                    }
+                    if (!('value' in descriptor)) {
+                        truncated = true;
+                        output[index] = '[Accessor]';
+                        continue;
+                    }
+                    output[index] = encode(descriptor.value, depth + 1, [
+                        ...path,
+                        String(index),
+                    ]);
+                }
+                return output;
+            }
+            if (current instanceof Map) {
+                return {
+                    $type: 'map',
+                    entries: [...current.entries()].map(([key, item], index) => [
+                        encode(key, depth + 1, [...path, String(index), 'key']),
+                        encode(item, depth + 1, [...path, String(index), 'value']),
+                    ]),
+                };
+            }
+            if (current instanceof Set) {
+                return {
+                    $type: 'set',
+                    values: [...current.values()].map((item, index) => encode(item, depth + 1, [...path, String(index)])),
+                };
+            }
+            const output = {};
+            for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(current))) {
+                if (!descriptor.enumerable)
+                    continue;
+                const nextPath = [...path, key];
+                if (shouldRedact(key, nextPath, redactions)) {
+                    redacted = true;
+                    output[key] = { $type: 'redacted' };
+                    continue;
+                }
+                if (!('value' in descriptor)) {
+                    truncated = true;
+                    output[key] = '[Accessor]';
+                    continue;
+                }
+                output[key] = encode(descriptor.value, depth + 1, nextPath);
+            }
+            return output;
+        }
+        finally {
+            seen.delete(current);
+        }
+    };
+    try {
+        const encoded = encode(value, 0, []);
+        const serialized = JSON.stringify(encoded);
+        const bytes = utf8ByteLength(serialized);
+        const preview = serialized.length > 512 ? `${serialized.slice(0, 509)}...` : serialized;
+        if (bytes > maxValueBytes) {
+            return {
+                preview,
+                truncated: true,
+                ...(redacted ? { redacted: true } : {}),
+                type: valueType(value),
+            };
+        }
+        return {
+            value: encoded,
+            preview,
+            ...(truncated ? { truncated: true } : {}),
+            ...(redacted ? { redacted: true } : {}),
+            type: valueType(value),
+        };
+    }
+    catch {
+        const type = safeValueType(value);
+        return {
+            preview: `[${type}]`,
+            truncated: true,
+            type,
+        };
+    }
+}
+function shouldRedact(key, path, redactions) {
+    if (redactions.size === 0)
+        return false;
+    const normalizedKey = key.toLowerCase();
+    const normalizedPath = path.join('.').toLowerCase();
+    return redactions.has(normalizedKey) || redactions.has(normalizedPath);
+}
+function valueType(value) {
+    return match(value)
+        .with(null, () => 'null')
+        .when(Array.isArray, () => 'array')
+        .when((candidate) => candidate instanceof Date, () => 'date')
+        .when((candidate) => candidate instanceof Uint8Array, () => 'bytes')
+        .when((candidate) => candidate instanceof Map, () => 'map')
+        .when((candidate) => candidate instanceof Set, () => 'set')
+        .when((candidate) => typeof candidate === 'object', () => 'object')
+        .otherwise((candidate) => typeof candidate);
+}
+function safeValueType(value) {
+    try {
+        return valueType(value);
+    }
+    catch {
+        return typeof value;
+    }
+}
+function utf8ByteLength(value) {
+    return new TextEncoder().encode(value).byteLength;
+}
+function bytesToBase64(value) {
+    let binary = '';
+    for (const byte of value)
+        binary += String.fromCharCode(byte);
+    const encoder = globalThis.btoa;
+    if (typeof encoder === 'function')
+        return encoder(binary);
+    return binary;
+}

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const LOUTRE_VERSION = "0.6.0";
+export declare const LOUTRE_VERSION = "0.8.0";

package/dist/generated/version.js

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

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>;