@loutrejs/loutre 0.5.0 → 0.6.0

package/dist/http/definitions.js

@@ -1,310 +0,0 @@
-import { childPipelineOf } from '../core/index.js';
-import { contractNodeBinding, contractNodeMetadata, protocolNamespaceBuilder, protocolNamespaceType, } from '../core/contract-internal.js';
-import { httpNodeMetadata } from './internal.js';
-import { assertValidHttpMethod, createHttpDispatchKey, parseHttpPath, } from './path.js';
-const controller = Object.freeze({
-    kind: 'terminal',
-    name: 'http.controller',
-    role: 'terminal',
-    protocol: 'http',
-});
-function defineHttp(definition) {
-    assertValidHttpMethod(definition.method);
-    for (const response of Object.values(definition.responses)) {
-        if (!Number.isInteger(response.status) ||
-            response.status < 200 ||
-            response.status > 599) {
-            throw new Error(`Invalid HTTP response status: ${response.status}`);
-        }
-    }
-    const segments = parseHttpPath(definition.path);
-    const paramsSchemas = definition.request?.params;
-    if (paramsSchemas) {
-        const pathNames = segments.flatMap((segment) => segment.kind === 'param' ? [segment.name] : []);
-        const schemaNames = Object.keys(paramsSchemas);
-        if (pathNames.length !== schemaNames.length ||
-            pathNames.some((name) => !Object.hasOwn(paramsSchemas, name))) {
-            throw new Error('HTTP path parameter names and request.params keys must match');
-        }
-    }
-    else if (hasParamsValidation(definition.pipeline)) {
-        throw new Error('validate.params requires request.params');
-    }
-    const body = definition.request?.body;
-    if (body && body.contentType.trim().length === 0) {
-        throw new Error('HTTP request body contentType must not be empty');
-    }
-    return {
-        kind: 'protocol',
-        protocol: 'http',
-        interaction: definition.interaction ?? 'unary',
-        dispatchKey: createHttpDispatchKey(definition.method, segments),
-        definition,
-    };
-}
-function hasParamsValidation(pipeline) {
-    return pipeline.some((item) => (item.kind === 'validation' && item.part === 'params') ||
-        (item.kind === 'layer' &&
-            hasParamsValidation(childPipelineOf(item) ?? [])));
-}
-function defineHttpGroup(definitions) {
-    const resolution = resolveHttpTree(definitions, {
-        path: '',
-        pipeline: [],
-        responses: {},
-        procedurePrefix: '',
-    });
-    const group = {
-        kind: 'protocol-group',
-        protocol: 'http',
-        procedures: Object.freeze({ ...resolution.procedures }),
-    };
-    Object.defineProperty(group, protocolNamespaceBuilder, {
-        enumerable: false,
-        value: (root) => buildHttpNamespace(resolution.tree, root, []),
-    });
-    return Object.freeze(group);
-}
-const HTTP_LEAF_PROPERTIES = new Set([
-    'method',
-    'path',
-    'summary',
-    'description',
-    'tags',
-    'deprecated',
-    'request',
-    'responses',
-    'pipeline',
-    'interaction',
-]);
-const HTTP_BRANCH_PROPERTIES = new Set([
-    'path',
-    'pipeline',
-    'responses',
-    'routes',
-]);
-function assertHttpRouteTreeObject(definitions) {
-    const prototype = Object.getPrototypeOf(definitions);
-    if (prototype !== Object.prototype && prototype !== null) {
-        throw new Error('HTTP route tree must be a plain object');
-    }
-}
-function assertHttpRouteName(name) {
-    if (name.length === 0 ||
-        name === '__proto__' ||
-        name.includes('.') ||
-        Number.isFinite(Number(name))) {
-        throw new Error(`Invalid HTTP Contract node name: ${JSON.stringify(name)}`);
-    }
-}
-function assertHttpNodeProperties(source) {
-    const allowed = 'method' in source ? HTTP_LEAF_PROPERTIES : HTTP_BRANCH_PROPERTIES;
-    for (const property of Object.keys(source)) {
-        if (!allowed.has(property)) {
-            throw new Error(`Unknown HTTP Contract node property: ${property}`);
-        }
-    }
-}
-function resolveHttpTree(definitions, context) {
-    assertHttpRouteTreeObject(definitions);
-    const procedures = {};
-    const tree = {};
-    for (const [name, candidate] of Object.entries(definitions)) {
-        assertHttpRouteName(name);
-        const metadata = typeof candidate === 'object' &&
-            candidate !== null &&
-            httpNodeMetadata in candidate
-            ? candidate[httpNodeMetadata]
-            : undefined;
-        const source = (metadata?.source ?? candidate);
-        assertHttpNodeProperties(source);
-        const procedureName = context.procedurePrefix === ''
-            ? name
-            : `${context.procedurePrefix}.${name}`;
-        if ('method' in source) {
-            const responses = mergeHttpResponses(context.responses, source.responses);
-            const definition = {
-                ...source,
-                path: joinHttpPath(context.path, source.path),
-                responses,
-                pipeline: [...context.pipeline, ...source.pipeline],
-            };
-            const protocol = defineHttp(definition);
-            procedures[procedureName] = protocol;
-            tree[name] = {
-                kind: 'leaf',
-                source,
-                handlerName: metadata?.kind === 'leaf' && metadata.handlerName
-                    ? metadata.handlerName
-                    : name,
-                protocol,
-            };
-            continue;
-        }
-        assertBranchPipeline(source.pipeline ?? []);
-        const branchResponses = mergeHttpResponses(context.responses, source.responses ?? {});
-        const branch = resolveHttpTree(source.routes, {
-            path: joinHttpPath(context.path, source.path ?? ''),
-            pipeline: [...context.pipeline, ...(source.pipeline ?? [])],
-            responses: branchResponses,
-            procedurePrefix: procedureName,
-        });
-        Object.assign(procedures, branch.procedures);
-        tree[name] = {
-            kind: 'branch',
-            source,
-            children: branch.tree,
-        };
-    }
-    return { procedures, tree: Object.freeze(tree) };
-}
-function joinHttpPath(parent, child) {
-    if (parent === '')
-        return child;
-    if (child === '' || child === '/')
-        return parent;
-    return `${parent}${child}`;
-}
-function mergeHttpResponses(parent, local) {
-    for (const name of Object.keys(local)) {
-        if (Object.hasOwn(parent, name)) {
-            throw new Error(`Duplicate inherited HTTP response variant: ${name}`);
-        }
-    }
-    return Object.freeze({ ...parent, ...local });
-}
-function assertBranchPipeline(pipeline) {
-    for (const item of pipeline) {
-        if (item.kind === 'terminal') {
-            throw new Error('HTTP branch pipeline must not contain a terminal layer');
-        }
-        if (item.kind === 'layer') {
-            const child = childPipelineOf(item);
-            if (child)
-                assertBranchPipeline(child);
-        }
-    }
-}
-function buildHttpNamespace(tree, root, parentPath) {
-    const namespace = {};
-    for (const [name, template] of Object.entries(tree)) {
-        namespace[name] = buildHttpNode(template, root, [...parentPath, name]);
-    }
-    return Object.freeze(namespace);
-}
-function buildHttpNode(template, root, path) {
-    if (template.kind === 'leaf') {
-        const binding = {
-            kind: 'contract',
-            procedures: Object.freeze({
-                [template.handlerName]: Object.freeze({
-                    kind: 'procedure',
-                    protocols: Object.freeze({ http: template.protocol }),
-                }),
-            }),
-        };
-        Object.defineProperty(binding, contractNodeMetadata, {
-            enumerable: false,
-            value: Object.freeze({
-                kind: 'leaf',
-                root,
-                path: Object.freeze(['http', ...path]),
-                procedures: Object.freeze({
-                    [template.handlerName]: path.join('.'),
-                }),
-            }),
-        });
-        Object.freeze(binding);
-        const node = {};
-        Object.defineProperty(node, contractNodeBinding, {
-            enumerable: false,
-            value: binding,
-        });
-        Object.defineProperty(node, httpNodeMetadata, {
-            enumerable: false,
-            value: Object.freeze({
-                kind: 'leaf',
-                root,
-                path: Object.freeze([...path]),
-                source: template.source,
-                handlerName: template.handlerName,
-            }),
-        });
-        return Object.freeze(node);
-    }
-    const children = buildHttpNamespace(template.children, root, path);
-    const procedures = {};
-    collectHttpNodeProcedures(template.children, '', procedures);
-    const binding = {
-        kind: 'contract',
-        procedures: Object.freeze(procedures),
-    };
-    Object.defineProperty(binding, contractNodeMetadata, {
-        enumerable: false,
-        value: Object.freeze({
-            kind: 'branch',
-            root,
-            path: Object.freeze(['http', ...path]),
-            procedures: Object.freeze(Object.fromEntries(Object.keys(procedures).map((procedure) => [
-                procedure,
-                [...path, procedure].join('.'),
-            ]))),
-        }),
-    });
-    Object.freeze(binding);
-    const node = { ...children };
-    Object.defineProperty(node, contractNodeBinding, {
-        enumerable: false,
-        value: binding,
-    });
-    Object.defineProperty(node, httpNodeMetadata, {
-        enumerable: false,
-        value: Object.freeze({
-            kind: 'branch',
-            root,
-            path: Object.freeze([...path]),
-            source: template.source,
-        }),
-    });
-    return Object.freeze(node);
-}
-function collectHttpNodeProcedures(tree, prefix, procedures) {
-    for (const [name, template] of Object.entries(tree)) {
-        const path = prefix === '' ? name : `${prefix}.${name}`;
-        if (template.kind === 'leaf') {
-            procedures[path] = Object.freeze({
-                kind: 'procedure',
-                protocols: Object.freeze({ http: template.protocol }),
-            });
-            continue;
-        }
-        collectHttpNodeProcedures(template.children, path, procedures);
-    }
-}
-export const http = Object.assign(defineHttpGroup, {
-    protocol: 'http',
-    route: defineHttp,
-    controller,
-    error: httpError,
-});
-function validationLayer(part) {
-    return Object.freeze({
-        kind: 'validation',
-        name: `validate.${part}`,
-        role: 'validation',
-        part,
-    });
-}
-export const validate = Object.freeze({
-    params: validationLayer('params'),
-    query: validationLayer('query'),
-    headers: validationLayer('headers'),
-    body: validationLayer('body'),
-});
-export function httpError(definition, map) {
-    return Object.freeze({
-        kind: 'http-error-mapping',
-        definition,
-        map: map ?? ((error) => ({ body: error.data })),
-    });
-}

package/dist/http/hosted-protocol.d.ts

@@ -1,4 +0,0 @@
-import { http as baseHttp } from './definitions.js';
-export declare const http: typeof baseHttp & {
-    readonly capabilities: readonly ['http'];
-};

package/dist/http/hosted-protocol.js

@@ -1,4 +0,0 @@
-import { http as baseHttp } from './definitions.js';
-export const http = Object.assign(baseHttp, {
-    capabilities: ['http'],
-});

package/dist/http/internal.d.ts

@@ -1,8 +0,0 @@
-export declare const httpNodeMetadata: unique symbol;
-export interface HttpNodeRuntimeMetadata {
-    readonly kind: 'leaf' | 'branch';
-    readonly root: object;
-    readonly path: readonly string[];
-    readonly source: object;
-    readonly handlerName?: string;
-}

package/dist/http/internal.js

@@ -1 +0,0 @@
-export const httpNodeMetadata = Symbol('loutre.http-node-metadata');

package/dist/http/params.d.ts

@@ -1,2 +0,0 @@
-import type { HttpParamsSchemas } from './definitions.js';
-export declare function validateHttpParamsSchemas(schemas: HttpParamsSchemas, value: Readonly<Record<string, string>>): Promise<Record<string, unknown>>;

package/dist/http/params.js

@@ -1,19 +0,0 @@
-import { SchemaValidationError, validateSchema } from '../core/index.js';
-export async function validateHttpParamsSchemas(schemas, value) {
-    const output = {};
-    for (const [name, schema] of Object.entries(schemas)) {
-        try {
-            output[name] = await validateSchema(schema, value[name]);
-        }
-        catch (error) {
-            if (error instanceof SchemaValidationError) {
-                throw new SchemaValidationError(error.issues.map((issue) => ({
-                    ...issue,
-                    path: [name, ...(issue.path ?? [])],
-                })));
-            }
-            throw error;
-        }
-    }
-    return output;
-}

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

@@ -1,4 +0,0 @@
-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

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

package/dist/http/validate.d.ts

@@ -1,20 +0,0 @@
-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

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

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

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

package/dist/message-port/environment.js

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

package/dist/runtime/application.d.ts

@@ -1,38 +0,0 @@
-import { type ArgsClass, type EnvClass, type ModuleInstance, type ModuleTemplate, type TaskArguments, type TaskDescriptor, type TaskOutput, type TokenLike } 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>;
-    get<T>(token: TokenLike<T>): T;
-    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;