@loutrejs/loutre 0.5.0 → 0.7.0

package/dist/http/application.js

@@ -1,515 +0,0 @@
-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 requires an 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 was aborted'));
-                    });
-                };
-                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);
-    const headers = mergeResponseHeaders(response.staticHeaders, responseHeaders);
-    if (response.status === 204 ||
-        response.status === 205 ||
-        response.status === 304) {
-        if (body !== undefined) {
-            throw new Error(`HTTP ${response.status} response body must be undefined`);
-        }
-        return new Response(undefined, { status: response.status, headers });
-    }
-    return jsonResponse(response.status, body, headers);
-}
-async function validateResponseHeaders(schema, headers) {
-    if (!schema) {
-        if (headers !== undefined) {
-            throw new Error('Undeclared HTTP response header was returned');
-        }
-        return undefined;
-    }
-    const validated = await validateSchema(schema, headers);
-    if (validated === undefined)
-        return undefined;
-    if (!isHttpHeaders(validated)) {
-        throw new Error('HTTP response header schema produced an invalid value');
-    }
-    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 must return a 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';
-    }
-}

package/dist/http/basic-auth.d.ts

@@ -1,37 +0,0 @@
-import { type ContextKey, type ContextKeyValue, type LayerDescriptor } from '../core/index.js';
-import type { LogicalHttpResult } from './definitions.js';
-export interface BasicAuthCredentials {
-    readonly username: string;
-    readonly password: string;
-}
-export interface BasicAuthUnauthorized<TVariant extends string, TBody> {
-    readonly variant: TVariant;
-    readonly body: TBody;
-}
-export interface BasicAuthOptions<TPrincipal extends ContextKey, TVariant extends string, TUnauthorizedBody> {
-    readonly realm: string;
-    readonly principal: TPrincipal;
-    readonly authenticate: (credentials: BasicAuthCredentials) => ContextKeyValue<TPrincipal> | null | undefined | Promise<ContextKeyValue<TPrincipal> | null | undefined>;
-    readonly unauthorized: BasicAuthUnauthorized<TVariant, TUnauthorizedBody>;
-    readonly name?: string;
-}
-type BasicAuthShortCircuits<TVariant extends string> = readonly [
-    {
-        readonly protocol: 'http';
-        readonly variant: TVariant;
-        readonly response: {
-            readonly status: 401;
-        };
-    }
-];
-type BasicAuthResponseHeaders = {
-    readonly 'www-authenticate': string;
-};
-export interface BasicAuthLayerDescriptor<TPrincipal extends ContextKey, TVariant extends string, TUnauthorizedBody> extends LayerDescriptor<readonly [], readonly [TPrincipal], string extends TVariant ? unknown : LogicalHttpResult<TVariant, TUnauthorizedBody, BasicAuthResponseHeaders>, BasicAuthShortCircuits<TVariant>, string, 'authentication', readonly [], BasicAuthContext> {
-    readonly role: 'authentication';
-}
-export interface BasicAuthContext {
-    readonly headers: Readonly<Record<string, string | undefined>>;
-}
-export declare function basicAuth<TPrincipal extends ContextKey, const TVariant extends string, TUnauthorizedBody>(options: BasicAuthOptions<TPrincipal, TVariant, TUnauthorizedBody>): BasicAuthLayerDescriptor<TPrincipal, TVariant, TUnauthorizedBody>;
-export {};

package/dist/http/basic-auth.js

@@ -1,67 +0,0 @@
-import { layer, shortCircuit, } from '../core/index.js';
-export function basicAuth(options) {
-    const challenge = formatBasicChallenge(options.realm);
-    const descriptor = layer({
-        name: options.name ?? 'basicAuth',
-        role: 'authentication',
-        provides: [options.principal],
-        shortCircuits: [
-            {
-                protocol: 'http',
-                variant: options.unauthorized.variant,
-                response: { status: 401 },
-            },
-        ],
-        factory: () => async (ctx, next) => {
-            const credentials = decodeBasicCredentials(ctx.headers.authorization);
-            if (!credentials) {
-                return unauthorizedResult(options.unauthorized, challenge);
-            }
-            const principal = await options.authenticate(credentials);
-            if (principal == null) {
-                return unauthorizedResult(options.unauthorized, challenge);
-            }
-            await next({
-                [options.principal.name]: principal,
-            });
-        },
-    });
-    return Object.freeze(descriptor);
-}
-function unauthorizedResult(unauthorized, challenge) {
-    return shortCircuit({
-        kind: 'http-result',
-        variant: unauthorized.variant,
-        body: unauthorized.body,
-        headers: {
-            'www-authenticate': challenge,
-        },
-    });
-}
-function formatBasicChallenge(realm) {
-    if (realm.length === 0 || /[\u0000-\u001f\u007f]/.test(realm)) {
-        throw new TypeError('Basic authentication realm cannot be empty or contain control characters');
-    }
-    const escaped = realm.replace(/[\\"]/g, '\\$&');
-    return `Basic realm="${escaped}", charset="UTF-8"`;
-}
-function decodeBasicCredentials(authorization) {
-    const match = /^Basic +([A-Za-z0-9+/]+={0,2})$/i.exec(authorization ?? '');
-    if (!match?.[1])
-        return undefined;
-    try {
-        const binary = atob(match[1]);
-        const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
-        const decoded = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
-        const separator = decoded.indexOf(':');
-        if (separator < 0)
-            return undefined;
-        return {
-            username: decoded.slice(0, separator),
-            password: decoded.slice(separator + 1),
-        };
-    }
-    catch {
-        return undefined;
-    }
-}