@loutrejs/loutre 0.1.0

package/dist/graph/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ir.js';
+export * from './graph.js';

package/dist/graph/index.js

@@ -0,0 +1,2 @@
+export * from './ir.js';
+export * from './graph.js';

package/dist/graph/ir.d.ts

@@ -0,0 +1,159 @@
+export interface ModuleIR {
+    readonly id: string;
+    readonly name?: string;
+    readonly description?: string;
+    readonly imports: readonly string[];
+    readonly environment: readonly string[];
+    readonly providers: readonly string[];
+    readonly exports: readonly string[];
+    readonly lifecycle: readonly string[];
+    readonly requires: readonly string[];
+}
+export interface ProviderIR {
+    readonly token: string;
+    readonly kind: 'class' | 'value' | 'factory' | 'conditional' | 'environment' | 'arguments';
+    readonly scope: 'application' | 'transient';
+    readonly dependencies: readonly string[];
+}
+export interface DependencyNodeIR {
+    readonly id: string;
+    readonly label: string;
+    readonly kind: 'class' | 'token' | 'factory' | 'conditional' | 'environment' | 'arguments' | 'implementation' | 'layer' | 'task' | 'framework';
+    readonly scope?: 'application' | 'transient';
+    readonly module?: string;
+}
+export interface DependencyEdgeIR {
+    readonly from: string;
+    readonly to: string;
+    readonly kind: 'inject' | 'factory' | 'lifecycle' | 'conditional' | 'framework';
+    readonly source: 'declared' | 'probed';
+    readonly condition?: {
+        readonly source: 'environment' | 'arguments';
+        readonly contract: string;
+        readonly key: string;
+        readonly equals: PropertyKey;
+    };
+}
+export interface TokenIR {
+    readonly id: string;
+}
+export interface ContextKeyIR {
+    readonly name: string;
+}
+export interface LayerIR {
+    readonly index: number;
+    readonly name: string;
+    readonly role: 'generic' | 'authentication' | 'guard' | 'validation' | 'framework' | 'terminal';
+    readonly requires: readonly string[];
+    readonly provides: readonly string[];
+    readonly returns?: readonly string[];
+    readonly requiresValidated: readonly string[];
+    readonly dependencies?: readonly string[];
+    readonly attributes?: Readonly<Record<string, string | number | boolean>>;
+    readonly pipeline?: readonly LayerIR[];
+    readonly shortCircuits?: readonly {
+        readonly protocol: string;
+        readonly variant: string;
+        readonly response?: Readonly<Record<string, unknown>>;
+    }[];
+}
+export interface PipelineIR {
+    readonly contract: string;
+    readonly procedure: string;
+    readonly protocol: string;
+    readonly layers: readonly LayerIR[];
+}
+export interface ImplementationIR {
+    readonly contract: string;
+    readonly procedure: string;
+    readonly protocol: string;
+    readonly implementation: string;
+    readonly method: string;
+}
+export interface CapabilityIR {
+    readonly name: string;
+    readonly scope: 'application' | 'execution';
+    readonly requiredBy: string;
+}
+export interface ProtocolExecutionRootIR {
+    readonly id: `protocol:${string}`;
+    readonly kind: 'protocol';
+    readonly protocol: string;
+    readonly contract: string;
+    readonly procedure: string;
+    readonly implementation: string;
+}
+export interface ApplicationArgumentsIR {
+    readonly name: string;
+}
+export interface TaskIR {
+    readonly id: `task:${string}`;
+    readonly name: string;
+    readonly public: boolean;
+}
+export interface TaskExecutionRootIR {
+    readonly id: `task:${string}`;
+    readonly kind: 'task';
+    readonly name: string;
+}
+export interface CronTriggerExecutionRootIR {
+    readonly id: `trigger:${string}`;
+    readonly kind: 'trigger';
+    readonly trigger: 'cron';
+    readonly name: string;
+    readonly expression: string;
+    readonly timezone: string;
+    readonly overlap: 'allow' | 'skip';
+    readonly task: string;
+}
+export interface FixedDelayTriggerExecutionRootIR {
+    readonly id: `trigger:${string}`;
+    readonly kind: 'trigger';
+    readonly trigger: 'fixed-delay';
+    readonly name: string;
+    readonly delay: number;
+    readonly immediate: boolean;
+    readonly task: string;
+}
+export interface QueueConsumerTriggerExecutionRootIR {
+    readonly id: `trigger:${string}`;
+    readonly kind: 'trigger';
+    readonly trigger: 'queue-consumer';
+    readonly name: string;
+    readonly queue: string;
+    readonly task: string;
+}
+export type TriggerExecutionRootIR = CronTriggerExecutionRootIR | FixedDelayTriggerExecutionRootIR | QueueConsumerTriggerExecutionRootIR;
+export type ExecutionRootIR = ProtocolExecutionRootIR | TaskExecutionRootIR | TriggerExecutionRootIR;
+export interface QueueIR {
+    readonly id: `queue:${string}`;
+    readonly name: string;
+    readonly payloadSchema: string;
+}
+export interface ApplicationGraphIR {
+    readonly modules: readonly ModuleIR[];
+    readonly arguments?: ApplicationArgumentsIR;
+    readonly providers: readonly ProviderIR[];
+    readonly tokens: readonly TokenIR[];
+    readonly contextKeys: readonly ContextKeyIR[];
+    readonly contracts: readonly string[];
+    readonly pipelines: readonly PipelineIR[];
+    readonly implementations: readonly ImplementationIR[];
+    readonly tasks: readonly TaskIR[];
+    readonly queues: readonly QueueIR[];
+    readonly executions: readonly ExecutionRootIR[];
+    readonly capabilities: readonly CapabilityIR[];
+    readonly hostCapabilities: readonly string[];
+    readonly nodes: readonly DependencyNodeIR[];
+    readonly edges: readonly DependencyEdgeIR[];
+    readonly diagnostics: readonly Diagnostic[];
+}
+export interface Diagnostic {
+    readonly code: string;
+    readonly message: string;
+    readonly path: string;
+}
+export interface CompilationResult {
+    readonly graph: ApplicationGraphIR;
+    readonly diagnostics: readonly Diagnostic[];
+}

package/dist/graph/ir.js

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

package/dist/http/application.d.ts

@@ -0,0 +1,18 @@
+import type { ApplicationGraphIR } from '../graph/index.js';
+import { ApplicationRuntime, Logger } from '../runtime/index.js';
+export interface HttpProtocolExecution {
+    readonly graph: ApplicationGraphIR;
+    initialize(): Promise<void>;
+    shutdown(signal?: string): Promise<void>;
+    onServerListening(url: string): void;
+    handle(request: Request): Promise<Response>;
+}
+export interface HttpProtocolExecutionLifecycle {
+    readonly onServerListening?: (url: string) => void;
+}
+export declare function createHttpExecution(options: {
+    readonly runtime: ApplicationRuntime;
+    readonly graph: ApplicationGraphIR;
+    readonly lifecycle?: HttpProtocolExecutionLifecycle;
+    readonly logger?: Logger;
+}): HttpProtocolExecution;

package/dist/http/application.js

@@ -0,0 +1,506 @@
+import { validateSchema, } from '../core/index.js';
+import { executePipeline, Logger, normalizeUnknownError, } from '../runtime/index.js';
+import { createCorsActualResponseHeaders, createCorsPreflightResponseHeaders, } from './cors.js';
+import { compareHttpPathSpecificity, HttpPathDecodeError, matchHttpPath, parseHttpPath, } from './path.js';
+import { validateHttpParamsSchemas } from './params.js';
+export function createHttpExecution(options) {
+    const { runtime } = options;
+    const graph = options.graph;
+    const applicationLogger = options.logger ?? new Logger();
+    const runtimeGraph = runtime.graph;
+    const container = runtime.container;
+    const routes = collectRoutes(runtimeGraph.modules);
+    const logger = applicationLogger.child({ protocol: 'http' });
+    let initialization;
+    const initialize = () => (initialization ??= runtime.initialize());
+    return {
+        graph,
+        initialize,
+        shutdown: (signal) => runtime.shutdown(signal),
+        onServerListening: (url) => options.lifecycle?.onServerListening?.(url),
+        async handle(request) {
+            const startedAt = Date.now();
+            const url = new URL(request.url);
+            const method = request.method.toUpperCase();
+            let requestLogger = logger.child({
+                executionId: crypto.randomUUID(),
+                method,
+                path: url.pathname,
+            });
+            try {
+                await initialize();
+            }
+            catch (error) {
+                return logHttpResponse(requestLogger, startedAt, createInternalErrorResponse(error, requestLogger));
+            }
+            return runtime.execute(async () => {
+                if (isCorsPreflightRequest(request)) {
+                    try {
+                        const requestedMethod = request.headers
+                            .get('access-control-request-method')
+                            .toUpperCase();
+                        const preflightMatch = findRoute(routes, requestedMethod, url.pathname);
+                        if (preflightMatch) {
+                            const headers = await createCorsPreflightResponseHeaders(preflightMatch.route.protocol.definition.pipeline, request, preflightMatch.route.method);
+                            if (headers) {
+                                requestLogger = requestLogger.child({
+                                    procedure: preflightMatch.route.procedure,
+                                    source: `${preflightMatch.route.implementation.name}.${preflightMatch.route.procedure}`,
+                                });
+                                return logHttpResponse(requestLogger, startedAt, new Response(null, { status: 204, headers }));
+                            }
+                        }
+                    }
+                    catch (error) {
+                        return logHttpResponse(requestLogger, startedAt, isDecodeError(error)
+                            ? jsonResponse(400, { error: 'Invalid request' })
+                            : createInternalErrorResponse(error, requestLogger));
+                    }
+                }
+                let routeMatch;
+                try {
+                    routeMatch = findRoute(routes, method, url.pathname);
+                }
+                catch (error) {
+                    return logHttpResponse(requestLogger, startedAt, isDecodeError(error)
+                        ? jsonResponse(400, { error: 'Invalid request' })
+                        : createInternalErrorResponse(error, requestLogger));
+                }
+                if (!routeMatch?.params) {
+                    return logHttpResponse(requestLogger, startedAt, jsonResponse(404, { error: 'Not Found' }));
+                }
+                requestLogger = requestLogger.child({
+                    procedure: routeMatch.route.procedure,
+                    source: `${routeMatch.route.implementation.name}.${routeMatch.route.procedure}`,
+                });
+                let corsHeaders;
+                try {
+                    corsHeaders = await createCorsActualResponseHeaders(routeMatch.route.protocol.definition.pipeline, request);
+                }
+                catch (error) {
+                    return logHttpResponse(requestLogger, startedAt, createInternalErrorResponse(error, requestLogger));
+                }
+                const complete = (response) => logHttpResponse(requestLogger, startedAt, applyFrameworkHeaders(response, corsHeaders));
+                try {
+                    const decoded = await decodeRequest(request, url, routeMatch.params, routeMatch.route.protocol.definition);
+                    const raw = {
+                        ...decoded,
+                        logger: requestLogger,
+                        signal: request.signal,
+                    };
+                    const logical = await executePipeline(routeMatch.route.protocol.definition.pipeline, {
+                        context: raw,
+                        layer: (descriptor) => container.layerRuntime(descriptor),
+                        validate: async (layer, context) => {
+                            const declared = routeMatch.route.protocol.definition.request?.[layer.part];
+                            const schema = layer.part === 'body' && declared
+                                ? declared.schema
+                                : declared;
+                            if (schema) {
+                                try {
+                                    context[layer.part] =
+                                        layer.part === 'params'
+                                            ? await validateHttpParamsSchemas(schema, context.params)
+                                            : await validateSchema(schema, context[layer.part]);
+                                }
+                                catch (error) {
+                                    throw new HttpInputValidationError(error);
+                                }
+                            }
+                        },
+                        terminal: async (_layer, context) => invokeController(routeMatch.route, context, container),
+                    });
+                    return complete(await finalizeResponse(routeMatch.route.protocol.definition, logical, request.signal));
+                }
+                catch (error) {
+                    if (error instanceof HttpUnsupportedMediaTypeError) {
+                        return complete(jsonResponse(415, { error: 'Unsupported Media Type' }));
+                    }
+                    if (isDecodeError(error)) {
+                        return complete(jsonResponse(400, { error: 'Invalid request' }));
+                    }
+                    if (isValidationError(error)) {
+                        return complete(jsonResponse(400, { error: 'Validation failed' }));
+                    }
+                    let mapped;
+                    try {
+                        mapped = await mapDeclaredError(routeMatch.route.protocol.definition, error);
+                    }
+                    catch (mappingError) {
+                        return complete(createInternalErrorResponse(mappingError, requestLogger));
+                    }
+                    if (mapped) {
+                        try {
+                            return complete(await finalizeResponse(routeMatch.route.protocol.definition, mapped, request.signal));
+                        }
+                        catch (finalizationError) {
+                            return complete(createInternalErrorResponse(finalizationError, requestLogger));
+                        }
+                    }
+                    return complete(createInternalErrorResponse(error, requestLogger));
+                }
+            });
+        },
+    };
+}
+function findRoute(routes, method, pathname) {
+    const candidate = routes
+        .filter((route) => route.method === method)
+        .map((route) => ({
+        route,
+        params: matchHttpPath(route.segments, pathname),
+    }))
+        .find((match) => match.params !== undefined);
+    return candidate?.params === undefined
+        ? undefined
+        : { route: candidate.route, params: candidate.params };
+}
+function isCorsPreflightRequest(request) {
+    return (request.method.toUpperCase() === 'OPTIONS' &&
+        request.headers.has('origin') &&
+        request.headers.has('access-control-request-method'));
+}
+function applyFrameworkHeaders(response, frameworkHeaders) {
+    if (!frameworkHeaders)
+        return response;
+    frameworkHeaders.forEach((value, name) => {
+        if (name.toLowerCase() === 'vary') {
+            for (const item of value.split(',')) {
+                appendVary(response.headers, item.trim());
+            }
+            return;
+        }
+        response.headers.set(name, value);
+    });
+    return response;
+}
+function appendVary(headers, value) {
+    if (value.length === 0)
+        return;
+    const current = headers.get('vary');
+    if (current === null) {
+        headers.set('vary', value);
+        return;
+    }
+    const values = current
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (!values.some((item) => item.toLowerCase() === value.toLowerCase())) {
+        values.push(value);
+    }
+    headers.set('vary', values.join(', '));
+}
+function logHttpResponse(logger, startedAt, response) {
+    logger.info('HTTP request completed', {
+        event: 'http.request.completed',
+        status: response.status,
+        durationMs: Math.max(0, Date.now() - startedAt),
+    });
+    return response;
+}
+function createInternalErrorResponse(error, logger) {
+    const normalized = normalizeUnknownError(error, logger.context);
+    logger.error('Unhandled application error', {
+        event: 'application.error',
+        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 }),
+        },
+    });
+    return jsonResponse(500, {
+        error: 'Internal Server Error',
+        errorId: normalized.errorId,
+    });
+}
+async function decodeRequest(request, url, params, definition) {
+    const query = {};
+    for (const [key, value] of url.searchParams) {
+        const current = query[key];
+        query[key] =
+            current === undefined
+                ? value
+                : Array.isArray(current)
+                    ? [...current, value]
+                    : [current, value];
+    }
+    const headers = Object.fromEntries(request.headers.entries());
+    let body = undefined;
+    const bodyDefinition = definition.request?.body;
+    if (bodyDefinition) {
+        const actualMediaType = normalizeMediaType(request.headers.get('content-type'));
+        const declaredMediaType = normalizeMediaType(bodyDefinition.contentType);
+        if (request.body !== null && actualMediaType !== declaredMediaType) {
+            throw new HttpUnsupportedMediaTypeError(declaredMediaType, actualMediaType);
+        }
+        if (declaredMediaType === 'application/json' ||
+            declaredMediaType.endsWith('+json')) {
+            try {
+                body = await request.json();
+            }
+            catch (error) {
+                throw new HttpInputDecodeError(error);
+            }
+        }
+        else if (declaredMediaType === 'multipart/form-data') {
+            try {
+                body = await request.formData();
+            }
+            catch (error) {
+                throw new HttpInputDecodeError(error);
+            }
+        }
+        else if (declaredMediaType.startsWith('text/')) {
+            body = await request.text();
+        }
+        else {
+            body = request.body;
+        }
+    }
+    return { params, query, headers, body };
+}
+function normalizeMediaType(value) {
+    const normalized = value?.split(';', 1)[0]?.trim().toLowerCase();
+    return normalized ? normalized : undefined;
+}
+async function invokeController(route, raw, container) {
+    const controller = container.implementationRuntime(route.implementation);
+    const method = controller[route.procedure];
+    if (typeof method !== 'function') {
+        throw new Error(`${route.implementation.name}.${route.procedure} is not callable`);
+    }
+    const response = Object.fromEntries(Object.keys(route.protocol.definition.responses).map((variant) => [
+        variant,
+        (result) => ({
+            kind: 'http-result',
+            variant,
+            body: result.body,
+            ...(result.headers === undefined ? {} : { headers: result.headers }),
+        }),
+    ]));
+    const context = {
+        ...raw,
+        response,
+    };
+    return Reflect.apply(method, controller, [
+        context,
+    ]);
+}
+async function finalizeResponse(definition, result, signal) {
+    if (result?.kind !== 'http-result') {
+        throw new Error('Controller returned a non-HTTP logical result');
+    }
+    const response = definition.responses[result.variant];
+    if (!response) {
+        throw new Error(`Undeclared HTTP response variant: ${result.variant}`);
+    }
+    const responseHeaders = await validateResponseHeaders(response.headers, result.headers);
+    if (response.stream === 'server') {
+        if (!isAsyncIterable(result.body)) {
+            throw new Error('server-stream responseにはAsyncIterableが必要です');
+        }
+        const encoder = new TextEncoder();
+        const iterator = result.body[Symbol.asyncIterator]();
+        let finished = false;
+        let abort;
+        const stream = new ReadableStream({
+            start(controller) {
+                abort = () => {
+                    if (finished)
+                        return;
+                    finished = true;
+                    signal.removeEventListener('abort', abort);
+                    void iterator.return?.(signal.reason).finally(() => {
+                        controller.error(signal.reason ?? new Error('HTTP requestが中断されました'));
+                    });
+                };
+                if (signal.aborted)
+                    abort();
+                else
+                    signal.addEventListener('abort', abort, { once: true });
+            },
+            async pull(controller) {
+                if (finished)
+                    return;
+                try {
+                    const next = await iterator.next();
+                    if (next.done) {
+                        finished = true;
+                        if (abort)
+                            signal.removeEventListener('abort', abort);
+                        controller.close();
+                        return;
+                    }
+                    const value = await validateSchema(response.body, next.value);
+                    controller.enqueue(encoder.encode(`data:${JSON.stringify(value)}\n\n`));
+                }
+                catch (error) {
+                    finished = true;
+                    if (abort)
+                        signal.removeEventListener('abort', abort);
+                    controller.error(error);
+                }
+            },
+            async cancel(reason) {
+                if (finished)
+                    return;
+                finished = true;
+                if (abort)
+                    signal.removeEventListener('abort', abort);
+                await iterator.return?.(reason);
+            },
+        });
+        return new Response(stream, {
+            status: response.status,
+            headers: mergeResponseHeaders(response.staticHeaders, responseHeaders, {
+                'content-type': 'text/event-stream; charset=utf-8',
+                'cache-control': 'no-cache',
+            }),
+        });
+    }
+    const body = await validateSchema(response.body, result.body);
+    return jsonResponse(response.status, body, mergeResponseHeaders(response.staticHeaders, responseHeaders));
+}
+async function validateResponseHeaders(schema, headers) {
+    if (!schema) {
+        if (headers !== undefined) {
+            throw new Error('未宣言のHTTP response headerが返されました');
+        }
+        return undefined;
+    }
+    const validated = await validateSchema(schema, headers);
+    if (validated === undefined)
+        return undefined;
+    if (!isHttpHeaders(validated)) {
+        throw new Error('HTTP response header schemaの出力が不正です');
+    }
+    return validated;
+}
+function isHttpHeaders(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return false;
+    }
+    return Object.values(value).every((header) => header === undefined ||
+        typeof header === 'string' ||
+        (Array.isArray(header) &&
+            header.every((item) => typeof item === 'string')));
+}
+function collectRoutes(modules) {
+    const routes = [];
+    for (const module of modules) {
+        for (const implementation of module.definition.implementations ?? []) {
+            if (implementation.protocol !== 'http')
+                continue;
+            for (const procedure of implementation.procedures) {
+                const protocol = implementation.contract.procedures[procedure]?.protocols.http;
+                if (!protocol || protocol.protocol !== 'http')
+                    continue;
+                const typed = protocol;
+                routes.push({
+                    method: typed.definition.method.toUpperCase(),
+                    path: typed.definition.path,
+                    segments: parseHttpPath(typed.definition.path),
+                    dispatchKey: typed.dispatchKey,
+                    protocol: typed,
+                    implementation,
+                    procedure,
+                });
+            }
+        }
+    }
+    return routes.toSorted((left, right) => compareHttpPathSpecificity(left.segments, right.segments));
+}
+function jsonResponse(status, body, headers = new Headers()) {
+    headers.set('content-type', 'application/json; charset=utf-8');
+    return new Response(JSON.stringify(body), {
+        status,
+        headers,
+    });
+}
+function mergeResponseHeaders(declared, dynamic, framework = undefined) {
+    const headers = new Headers();
+    applyResponseHeaders(headers, declared);
+    applyResponseHeaders(headers, dynamic);
+    applyResponseHeaders(headers, framework);
+    return headers;
+}
+function applyResponseHeaders(headers, source) {
+    if (!source)
+        return;
+    for (const [name, value] of Object.entries(source)) {
+        if (value === undefined)
+            continue;
+        headers.delete(name);
+        if (typeof value === 'string') {
+            headers.set(name, value);
+            continue;
+        }
+        for (const item of value)
+            headers.append(name, item);
+    }
+}
+function isValidationError(error) {
+    return error instanceof HttpInputValidationError;
+}
+function isDecodeError(error) {
+    return (error instanceof HttpInputDecodeError ||
+        error instanceof HttpPathDecodeError);
+}
+async function mapDeclaredError(definition, error) {
+    for (const [variant, response] of Object.entries(definition.responses)) {
+        const errorMapping = response.error;
+        if (errorMapping?.definition.is(error)) {
+            const result = await errorMapping.map(error);
+            if (typeof result !== 'object' ||
+                result === null ||
+                !('body' in result)) {
+                throw new Error('HTTP error mappingはbodyを返す必要があります');
+            }
+            return {
+                kind: 'http-result',
+                variant,
+                body: result.body,
+                ...('headers' in result
+                    ? { headers: result.headers }
+                    : {}),
+            };
+        }
+    }
+    return undefined;
+}
+function isAsyncIterable(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        Symbol.asyncIterator in value &&
+        typeof value[Symbol.asyncIterator] === 'function');
+}
+class HttpInputValidationError extends Error {
+    cause;
+    constructor(cause) {
+        super('HTTP input validation failed', { cause });
+        this.cause = cause;
+        this.name = 'HttpInputValidationError';
+    }
+}
+class HttpInputDecodeError extends Error {
+    cause;
+    constructor(cause) {
+        super('HTTP input decode failed', { cause });
+        this.cause = cause;
+        this.name = 'HttpInputDecodeError';
+    }
+}
+class HttpUnsupportedMediaTypeError extends Error {
+    expected;
+    actual;
+    constructor(expected, actual) {
+        super(`Unsupported HTTP request media type: expected ${expected}, received ${actual ?? '(missing)'}`);
+        this.expected = expected;
+        this.actual = actual;
+        this.name = 'HttpUnsupportedMediaTypeError';
+    }
+}