@loutrejs/loutre 0.1.0

package/dist/http/path.d.ts

@@ -0,0 +1,55 @@
+type AsciiLowercase = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+type AsciiLetter = AsciiLowercase | Uppercase<AsciiLowercase>;
+type AsciiDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+type ParamNameStart = AsciiLetter | '_';
+type ParamNameContinuation = ParamNameStart | AsciiDigit;
+type IsParamNameRest<TName extends string> = TName extends '' ? true : TName extends `${ParamNameContinuation}${infer TRest}` ? IsParamNameRest<TRest> : false;
+type IsParamName<TName extends string> = TName extends `${ParamNameStart}${infer TRest}` ? IsParamNameRest<TRest> : false;
+type IsStaticSegment<TSegment extends string> = TSegment extends '' ? false : TSegment extends `${string}{${string}` | `${string}}${string}` ? false : TSegment extends `${string}?${string}` | `${string}#${string}` ? false : true;
+type ValidatePathSegments<TSegments extends string, TSeen extends string = never> = TSegments extends `${infer THead}/${infer TTail}` ? ValidatePathSegment<THead, TSeen> extends infer TResult ? TResult extends {
+    readonly valid: true;
+    readonly seen: infer TNext extends string;
+} ? ValidatePathSegments<TTail, TNext> : false : false : ValidatePathSegment<TSegments, TSeen> extends {
+    readonly valid: true;
+} ? true : false;
+type ValidatePathSegment<TSegment extends string, TSeen extends string> = TSegment extends `{${infer TName}}` ? IsParamName<TName> extends true ? TName extends TSeen ? {
+    readonly valid: false;
+} : {
+    readonly valid: true;
+    readonly seen: TSeen | TName;
+} : {
+    readonly valid: false;
+} : IsStaticSegment<TSegment> extends true ? {
+    readonly valid: true;
+    readonly seen: TSeen;
+} : {
+    readonly valid: false;
+};
+export type IsValidHttpPath<TPath extends string> = string extends TPath ? false : TPath extends '/' ? true : TPath extends `/${infer TSegments}` ? ValidatePathSegments<TSegments> : false;
+type PathParamNamesFromSegments<TSegments extends string> = TSegments extends `${infer THead}/${infer TTail}` ? PathParamName<THead> | PathParamNamesFromSegments<TTail> : PathParamName<TSegments>;
+type PathParamName<TSegment extends string> = TSegment extends `{${infer TName}}` ? TName : never;
+export type PathParamNames<TPath extends string> = TPath extends `/${infer TSegments}` ? PathParamNamesFromSegments<TSegments> : never;
+export type RawPathParams<TPath extends string> = Readonly<{
+    [TName in PathParamNames<TPath>]: string;
+}>;
+type NormalizeHttpPathSegments<TSegments extends string> = TSegments extends `${infer THead}/${infer TTail}` ? `${NormalizeHttpPathSegment<THead>}/${NormalizeHttpPathSegments<TTail>}` : NormalizeHttpPathSegment<TSegments>;
+type NormalizeHttpPathSegment<TSegment extends string> = TSegment extends `{${string}}` ? '{}' : TSegment;
+export type NormalizeHttpPath<TPath extends string> = TPath extends '/' ? '/' : string extends TPath ? string : TPath extends `/${infer TSegments}` ? `/${NormalizeHttpPathSegments<TSegments>}` : never;
+export type HttpDispatchKey<TMethod extends string, TPath extends string> = `http:${Uppercase<TMethod>}:${NormalizeHttpPath<TPath>}`;
+export type HttpPathSegment = {
+    readonly kind: 'static';
+    readonly value: string;
+} | {
+    readonly kind: 'param';
+    readonly name: string;
+};
+export declare function parseHttpPath(path: string): readonly HttpPathSegment[];
+export declare function normalizeHttpPath(segments: readonly HttpPathSegment[]): string;
+export declare function createHttpDispatchKey(method: string, segments: readonly HttpPathSegment[]): string;
+export declare function matchHttpPath(segments: readonly HttpPathSegment[], pathname: string): Record<string, string> | undefined;
+export declare function compareHttpPathSpecificity(left: readonly HttpPathSegment[], right: readonly HttpPathSegment[]): number;
+export declare class HttpPathDecodeError extends Error {
+    readonly cause: unknown;
+    constructor(cause: unknown);
+}
+export {};

package/dist/http/path.js

@@ -0,0 +1,88 @@
+const PARAM_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+export function parseHttpPath(path) {
+    if (path === '/')
+        return Object.freeze([]);
+    if (!path.startsWith('/')) {
+        throw new Error(`Invalid HTTP path: ${path}`);
+    }
+    if (path.endsWith('/') || path.includes('//')) {
+        throw new Error(`Invalid HTTP path segment: ${path}`);
+    }
+    if (path.includes('?') || path.includes('#')) {
+        throw new Error(`HTTP path must not contain a query or fragment: ${path}`);
+    }
+    const names = new Set();
+    const segments = path
+        .slice(1)
+        .split('/')
+        .map((segment) => {
+        if (segment.startsWith('{') || segment.endsWith('}')) {
+            const match = /^\{([^{}]*)\}$/.exec(segment);
+            const name = match?.[1];
+            if (!name || !PARAM_NAME_PATTERN.test(name)) {
+                throw new Error(`Invalid HTTP path parameter: ${segment}`);
+            }
+            if (names.has(name)) {
+                throw new Error(`Duplicate HTTP path parameter: ${name}`);
+            }
+            names.add(name);
+            return Object.freeze({ kind: 'param', name });
+        }
+        if (segment.includes('{') || segment.includes('}')) {
+            throw new Error(`Inline HTTP path parameters are not supported: ${segment}`);
+        }
+        return Object.freeze({ kind: 'static', value: segment });
+    });
+    return Object.freeze(segments);
+}
+export function normalizeHttpPath(segments) {
+    if (segments.length === 0)
+        return '/';
+    return `/${segments
+        .map((segment) => (segment.kind === 'static' ? segment.value : '{}'))
+        .join('/')}`;
+}
+export function createHttpDispatchKey(method, segments) {
+    return `http:${method.toUpperCase()}:${normalizeHttpPath(segments)}`;
+}
+export function matchHttpPath(segments, pathname) {
+    const requestSegments = pathname === '/' ? [] : pathname.slice(1).split('/');
+    if (requestSegments.length !== segments.length)
+        return undefined;
+    const params = {};
+    for (let index = 0; index < segments.length; index += 1) {
+        const routeSegment = segments[index];
+        const requestSegment = requestSegments[index];
+        if (routeSegment.kind === 'static') {
+            if (routeSegment.value !== requestSegment)
+                return undefined;
+            continue;
+        }
+        try {
+            params[routeSegment.name] = decodeURIComponent(requestSegment);
+        }
+        catch (error) {
+            throw new HttpPathDecodeError(error);
+        }
+    }
+    return params;
+}
+export function compareHttpPathSpecificity(left, right) {
+    const length = Math.min(left.length, right.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftSegment = left[index];
+        const rightSegment = right[index];
+        if (leftSegment.kind === rightSegment.kind)
+            continue;
+        return leftSegment.kind === 'static' ? -1 : 1;
+    }
+    return right.length - left.length;
+}
+export class HttpPathDecodeError extends Error {
+    cause;
+    constructor(cause) {
+        super('HTTP path decode failed', { cause });
+        this.cause = cause;
+        this.name = 'HttpPathDecodeError';
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { StandardSchemaV1 } from '../core/index.js';
+import type { HttpRequestBodyDefinition } from './definitions.js';
+export declare function httpRequestBodySchema(body: HttpRequestBodyDefinition): StandardSchemaV1;
+export declare function httpRequestBodyContentType(body: HttpRequestBodyDefinition): string;

package/dist/http/request-body.js

@@ -0,0 +1,6 @@
+export function httpRequestBodySchema(body) {
+    return body.schema;
+}
+export function httpRequestBodyContentType(body) {
+    return body.contentType;
+}

package/dist/http/validate.d.ts

@@ -0,0 +1,20 @@
+import { cors } from './cors.js';
+export declare const validate: Readonly<{
+    params: import("../index.js").ValidationLayerDescriptor & {
+        readonly part: "params";
+        readonly name: "validate.params";
+    };
+    query: import("../index.js").ValidationLayerDescriptor & {
+        readonly part: "query";
+        readonly name: "validate.query";
+    };
+    headers: import("../index.js").ValidationLayerDescriptor & {
+        readonly part: "headers";
+        readonly name: "validate.headers";
+    };
+    body: import("../index.js").ValidationLayerDescriptor & {
+        readonly part: "body";
+        readonly name: "validate.body";
+    };
+    cors: typeof cors;
+}>;

package/dist/http/validate.js

@@ -0,0 +1,6 @@
+import { cors } from './cors.js';
+import { validate as inputValidation } from './definitions.js';
+export const validate = Object.freeze({
+    ...inputValidation,
+    cors,
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './core/index.js';
+export * from './application/index.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './core/index.js';
+export * from './application/index.js';

package/dist/message-port/environment.d.ts

@@ -0,0 +1,2 @@
+import type { MessagePortProtocolExecution } from './index.js';
+export declare function initializeMessagePortExecution(application: MessagePortProtocolExecution, environmentSource: unknown): Promise<void>;

package/dist/message-port/environment.js

@@ -0,0 +1,4 @@
+import { initializeWithEnvironment } from '../runtime/index.js';
+export function initializeMessagePortExecution(application, environmentSource) {
+    return initializeWithEnvironment(application, environmentSource);
+}

package/dist/message-port/index.d.ts

@@ -0,0 +1,65 @@
+import { type ContextProvidedBeforeTerminal, type IsValidProtocolPipeline, type ContractDefinition, type PipelineItem, type ProtocolDescriptor, type SchemaOutput, type StandardSchemaV1, type TerminalLayerDescriptor } from '../core/index.js';
+import type { ApplicationGraphIR } from '../graph/index.js';
+import { ApplicationRuntime, Logger } from '../runtime/index.js';
+export interface MessagePortResponseDefinition {
+    readonly body: StandardSchemaV1;
+    readonly stream?: 'server';
+}
+export interface MessagePortProtocolDefinition {
+    readonly interaction?: 'unary' | 'server-stream';
+    readonly responses: Readonly<Record<string, MessagePortResponseDefinition>>;
+    readonly pipeline: readonly PipelineItem[];
+}
+export interface MessagePortProtocol<TDefinition extends MessagePortProtocolDefinition = MessagePortProtocolDefinition> extends ProtocolDescriptor<'messagePort', MessagePortHandlerContextDefinition<TDefinition>, LogicalMessagePortResult> {
+    readonly definition: TDefinition;
+}
+declare function defineMessagePort<const TDefinition extends MessagePortProtocolDefinition>(definition: TDefinition & MessagePortPipelineConstraint<TDefinition>): MessagePortProtocol<TDefinition>;
+type MessagePortPipelineConstraint<TDefinition extends MessagePortProtocolDefinition> = IsValidProtocolPipeline<TDefinition['pipeline'], 'messagePort'> extends true ? unknown : {
+    readonly pipeline: never;
+};
+export declare const messagePort: typeof defineMessagePort & {
+    protocol: 'messagePort';
+    handler: TerminalLayerDescriptor<"messagePort">;
+};
+export interface LogicalMessagePortResult<TVariant extends string = string, TValue = unknown> {
+    readonly kind: 'message-port-result';
+    readonly variant: TVariant;
+    readonly value: TValue;
+}
+type ProceduresForMessagePort<TContract extends ContractDefinition> = {
+    [K in keyof TContract['procedures']]: 'messagePort' extends keyof TContract['procedures'][K]['protocols'] ? K : never;
+}[keyof TContract['procedures']] & string;
+type ProtocolAt<TContract extends ContractDefinition, TProcedure extends keyof TContract['procedures']> = TContract['procedures'][TProcedure]['protocols']['messagePort' & keyof TContract['procedures'][TProcedure]['protocols']] extends infer TProtocol ? TProtocol extends MessagePortProtocol ? TProtocol : never : never;
+type MessageHelpers<TProtocol extends MessagePortProtocol> = {
+    [TVariant in keyof TProtocol['definition']['responses'] & string]: (value: TProtocol['definition']['responses'][TVariant] extends {
+        readonly stream: 'server';
+    } ? AsyncIterable<SchemaOutput<TProtocol['definition']['responses'][TVariant]['body']>> : SchemaOutput<TProtocol['definition']['responses'][TVariant]['body']>) => LogicalMessagePortResult;
+};
+type MessagePortHandlerContextDefinition<TDefinition extends MessagePortProtocolDefinition> = {
+    readonly input: unknown;
+    readonly message: MessageHelpers<MessagePortProtocol<TDefinition>>;
+    readonly logger: Logger;
+} & ContextProvidedBeforeTerminal<TDefinition['pipeline']>;
+export type MessagePortHandlerContext<TProtocol extends MessagePortProtocol> = MessagePortHandlerContextDefinition<TProtocol['definition']>;
+export type HandlerOf<TContract extends ContractDefinition, TProtocol extends 'messagePort', TProcedures extends ProceduresForMessagePort<TContract> = ProceduresForMessagePort<TContract>> = TProtocol extends 'messagePort' ? {
+    [K in TProcedures]: (context: MessagePortHandlerContext<ProtocolAt<TContract, K>>) => LogicalMessagePortResult | Promise<LogicalMessagePortResult>;
+} : never;
+export type MessageContextOf<THandler, TProcedure extends keyof THandler> = THandler[TProcedure] extends (context: infer TContext, ...args: any[]) => any ? TContext : never;
+export interface MessagePortProtocolExecution {
+    readonly graph: ApplicationGraphIR;
+    initialize(): Promise<void>;
+    shutdown(signal?: string): Promise<void>;
+    invoke(procedure: string, input?: unknown): Promise<LogicalMessagePortResult>;
+}
+export declare function createMessagePortExecution(options: {
+    readonly runtime: ApplicationRuntime;
+    readonly graph: ApplicationGraphIR;
+    readonly logger?: Logger;
+}): MessagePortProtocolExecution;
+export interface MessagePortLike {
+    postMessage(value: unknown): void;
+    addEventListener(type: string, listener: (event: any) => void): void;
+    start?(): void;
+}
+export declare function attachMessagePort(application: MessagePortProtocolExecution, port: MessagePortLike): void;
+export {};

package/dist/message-port/index.js

@@ -0,0 +1,182 @@
+import { validateSchema, } from '../core/index.js';
+import { executePipeline, Logger, normalizeUnknownError, } from '../runtime/index.js';
+const handler = Object.freeze({
+    kind: 'terminal',
+    name: 'messagePort.handler',
+    role: 'terminal',
+    protocol: 'messagePort',
+});
+function defineMessagePort(definition) {
+    return {
+        kind: 'protocol',
+        protocol: 'messagePort',
+        interaction: definition.interaction ?? 'unary',
+        dispatchKey: null,
+        definition,
+    };
+}
+export const messagePort = Object.assign(defineMessagePort, {
+    protocol: 'messagePort',
+    handler,
+});
+export function createMessagePortExecution(options) {
+    const graph = options.graph;
+    const applicationLogger = options.logger ?? new Logger();
+    const runtime = options.runtime;
+    const logger = applicationLogger.child({ protocol: 'messagePort' });
+    const routes = collectRoutes(runtime.graph.modules);
+    let initialization;
+    const initialize = () => (initialization ??= runtime.initialize());
+    return {
+        graph,
+        initialize,
+        shutdown: (signal) => runtime.shutdown(signal),
+        async invoke(procedure, input) {
+            const startedAt = Date.now();
+            let invocationLogger = logger.child({
+                procedure,
+                executionId: crypto.randomUUID(),
+            });
+            try {
+                return await runtime.execute(async () => {
+                    const route = routes.find((candidate) => candidate.procedure === procedure);
+                    if (!route)
+                        throw new Error(`MessagePort procedureがありません: ${procedure}`);
+                    invocationLogger = invocationLogger.child({
+                        source: `${route.implementation.name}.${route.procedure}`,
+                    });
+                    const message = Object.fromEntries(Object.keys(route.protocol.definition.responses).map((variant) => [
+                        variant,
+                        (value) => ({
+                            kind: 'message-port-result',
+                            variant,
+                            value,
+                        }),
+                    ]));
+                    const context = {
+                        input,
+                        message,
+                        logger: invocationLogger,
+                    };
+                    const result = await executePipeline(route.protocol.definition.pipeline, {
+                        context,
+                        layer: (descriptor) => runtime.container.layerRuntime(descriptor),
+                        validate: () => undefined,
+                        terminal: async (_layer, terminalContext) => {
+                            const target = runtime.container.implementationRuntime(route.implementation);
+                            const method = target[route.procedure];
+                            if (typeof method !== 'function')
+                                throw new Error('Handler methodがありません');
+                            return Reflect.apply(method, target, [
+                                terminalContext,
+                            ]);
+                        },
+                    });
+                    const finalized = await finalize(route.protocol.definition, result);
+                    invocationLogger.info('MessagePort invocation completed', {
+                        event: 'message_port.invocation.completed',
+                        durationMs: Math.max(0, Date.now() - startedAt),
+                    });
+                    return finalized;
+                });
+            }
+            catch (error) {
+                const normalized = normalizeUnknownError(error, invocationLogger.context);
+                invocationLogger.error('Unhandled application error', {
+                    event: 'application.error',
+                    durationMs: Math.max(0, Date.now() - startedAt),
+                    error: {
+                        code: normalized.code,
+                        id: normalized.errorId,
+                        name: error instanceof Error ? error.name : typeof error,
+                        message: normalized.message,
+                        ...(normalized.stack === undefined
+                            ? {}
+                            : { stack: normalized.stack }),
+                        ...(normalized.cause === undefined
+                            ? {}
+                            : { cause: normalized.cause }),
+                    },
+                });
+                throw error;
+            }
+        },
+    };
+}
+async function finalize(definition, result) {
+    const response = definition.responses[result.variant];
+    if (!response)
+        throw new Error(`未宣言variantです: ${result.variant}`);
+    if (response.stream === 'server') {
+        if (!isAsyncIterable(result.value)) {
+            throw new Error('server-stream resultにはAsyncIterableが必要です');
+        }
+        const source = result.value;
+        return {
+            ...result,
+            value: (async function* () {
+                for await (const value of source) {
+                    yield await validateSchema(response.body, value);
+                }
+            })(),
+        };
+    }
+    return { ...result, value: await validateSchema(response.body, result.value) };
+}
+function collectRoutes(modules) {
+    return modules.flatMap((module) => (module.definition.implementations ?? []).flatMap((implementation) => {
+        if (implementation.protocol !== 'messagePort')
+            return [];
+        return implementation.procedures.map((procedure) => ({
+            procedure,
+            protocol: implementation.contract.procedures[procedure].protocols
+                .messagePort,
+            implementation,
+        }));
+    }));
+}
+export function attachMessagePort(application, port) {
+    port.addEventListener('message', async (event) => {
+        const request = event.data;
+        try {
+            const result = await application.invoke(request.procedure, request.input);
+            if (isAsyncIterable(result.value)) {
+                for await (const value of result.value) {
+                    port.postMessage({
+                        id: request.id,
+                        variant: result.variant,
+                        value,
+                        done: false,
+                    });
+                }
+                port.postMessage({
+                    id: request.id,
+                    variant: result.variant,
+                    done: true,
+                });
+            }
+            else {
+                port.postMessage({
+                    id: request.id,
+                    variant: result.variant,
+                    value: result.value,
+                    done: true,
+                });
+            }
+        }
+        catch (error) {
+            port.postMessage({
+                id: request.id,
+                error: error instanceof Error ? error.message : String(error),
+                done: true,
+            });
+        }
+    });
+    port.start?.();
+}
+function isAsyncIterable(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        Symbol.asyncIterator in value &&
+        typeof value[Symbol.asyncIterator] === 'function');
+}

package/dist/runtime/application.d.ts

@@ -0,0 +1,37 @@
+import { type ArgsClass, type EnvClass, type ModuleInstance, type ModuleTemplate, type TaskArguments, type TaskDescriptor, type TaskOutput } from '../core/index.js';
+import { Container, type RuntimeModuleGraph } from './di.js';
+import { Logger } from './logger.js';
+export interface ApplicationRuntimeOptions {
+    readonly logger?: Logger;
+    readonly environmentSource?: unknown;
+    readonly arguments?: ArgsClass;
+    readonly argumentsSource?: unknown;
+    readonly tasks?: readonly TaskDescriptor<any, any>[];
+    readonly publicTasks?: readonly TaskDescriptor<any, any>[];
+}
+export interface InitializableApplication {
+    initialize(): Promise<void>;
+}
+export declare function initializeWithEnvironment(application: InitializableApplication, environmentSource: unknown): Promise<void>;
+export declare class EnvironmentBindingError extends Error {
+    readonly code = "LUTRE_ENV_003";
+    constructor(environment: EnvClass, cause: unknown);
+}
+export declare class ArgumentsBindingError extends Error {
+    readonly code = "LUTRE_ARGS_003";
+    constructor(argumentsContract: ArgsClass, cause: unknown);
+}
+export declare class ApplicationRuntime {
+    #private;
+    readonly graph: RuntimeModuleGraph;
+    readonly container: Container;
+    constructor(roots: readonly (ModuleInstance | ModuleTemplate<void>)[], options?: ApplicationRuntimeOptions);
+    initialize(): Promise<void>;
+    run<TTask extends TaskDescriptor<any, any>>(task: TTask, ...args: TaskArguments<TTask>): Promise<TaskOutput<TTask>>;
+    /** public run()ではTrigger専用Taskを拒否するため、Trigger Host専用経路を分ける。 */
+    runTask<TTask extends TaskDescriptor<any, any>>(task: TTask, ...args: TaskArguments<TTask>): Promise<TaskOutput<TTask>>;
+    execute<T>(execution: () => T | Promise<T>): Promise<T>;
+    stopAcceptingExecutions(): void;
+    shutdown(signal?: string): Promise<void>;
+}
+export declare function createApplicationRuntime(roots: readonly (ModuleInstance | ModuleTemplate<void>)[], options?: ApplicationRuntimeOptions): ApplicationRuntime;