@loutrejs/loutre 0.5.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loutrejs/loutre",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "license": "MIT",
   "type": "module",
   "files": [
@@ -12,18 +12,6 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./host": {
-      "types": "./dist/application/host.d.ts",
-      "import": "./dist/application/host.js"
-    },
-    "./binding": {
-      "types": "./dist/application/binding.d.ts",
-      "import": "./dist/application/binding.js"
-    },
-    "./openapi": {
-      "types": "./dist/application/openapi.d.ts",
-      "import": "./dist/application/openapi.js"
-    },
     "./presentation": {
       "types": "./dist/presentation.d.ts",
       "import": "./dist/presentation.js"
@@ -32,6 +20,10 @@
       "types": "./dist/graph/index.d.ts",
       "import": "./dist/graph/index.js"
     },
+    "./devtools": {
+      "types": "./dist/devtools/index.d.ts",
+      "import": "./dist/devtools/index.js"
+    },
     "./runtime": {
       "types": "./dist/runtime/index.d.ts",
       "import": "./dist/runtime/index.js"
@@ -40,13 +32,17 @@
       "types": "./dist/http/index.d.ts",
       "import": "./dist/http/index.js"
     },
+    "./tasks": {
+      "types": "./dist/tasks/index.d.ts",
+      "import": "./dist/tasks/index.js"
+    },
     "./message-port": {
       "types": "./dist/message-port/index.d.ts",
       "import": "./dist/message-port/index.js"
     },
-    "./message-port/environment": {
-      "types": "./dist/message-port/environment.d.ts",
-      "import": "./dist/message-port/environment.js"
+    "./websocket": {
+      "types": "./dist/websocket/index.d.ts",
+      "import": "./dist/websocket/index.js"
     },
     "./runtime/bun": {
       "types": "./dist/adapters/bun.d.ts",
@@ -67,6 +63,10 @@
     "./runtime/electron": {
       "types": "./dist/adapters/electron.d.ts",
       "import": "./dist/adapters/electron.js"
+    },
+    "./http/openapi": {
+      "types": "./dist/http/openapi.d.ts",
+      "import": "./dist/http/openapi.js"
     }
   },
   "sideEffects": false,

package/dist/application/binding.d.ts

@@ -1,33 +0,0 @@
-import { type ProviderDescriptor, type QueueDescriptor } from '../core/index.js';
-import { type HttpProtocolExecution } from '../http/index.js';
-import { type MessagePortProtocolExecution } from '../message-port/index.js';
-import type { ApplicationDefinition, BootstrapArguments, HasHttp, HasMessagePort, HasTriggers, InvocationApplication, QueueConsumerDriver, TriggerApplicationCapability } from './index.js';
-type IsAny<TValue> = 0 extends 1 & TValue ? true : false;
-type ProtocolBinding<TDefinition extends ApplicationDefinition> = IsAny<TDefinition> extends true ? {
-    readonly http?: HttpProtocolExecution;
-    readonly messagePort?: MessagePortProtocolExecution;
-} : (HasHttp<TDefinition> extends true ? {
-    readonly http: HttpProtocolExecution;
-} : {}) & (HasMessagePort<TDefinition> extends true ? {
-    readonly messagePort: MessagePortProtocolExecution;
-} : {});
-export type InvocationBinding<TDefinition extends ApplicationDefinition> = {
-    readonly application: InvocationApplication<TDefinition>;
-} & ProtocolBinding<TDefinition>;
-export type HostBindingApplication<TDefinition extends ApplicationDefinition> = InvocationApplication<TDefinition> & (HasTriggers<TDefinition> extends true ? TriggerApplicationCapability : {});
-export type HostBinding<TDefinition extends ApplicationDefinition> = {
-    readonly application: HostBindingApplication<TDefinition>;
-} & ProtocolBinding<TDefinition>;
-export interface InvocationBindingBaseOptions<TDefinition extends ApplicationDefinition> {
-    readonly application: TDefinition;
-    readonly environment?: unknown;
-}
-export type InvocationBindingOptions<TDefinition extends ApplicationDefinition> = InvocationBindingBaseOptions<TDefinition> & BootstrapArguments<TDefinition>;
-interface BindingApi {
-    invocation<const TDefinition extends ApplicationDefinition>(options: InvocationBindingOptions<TDefinition>): InvocationBinding<TDefinition>;
-    host<const TDefinition extends ApplicationDefinition>(options: InvocationBindingOptions<TDefinition>): HostBinding<TDefinition>;
-    queue(descriptor: QueueDescriptor, driver: QueueConsumerDriver): ProviderDescriptor;
-}
-/** flatなcreateXXX/bindXXX APIを増殖させないため、外部bindingをnamespaceへ集約する。 */
-export declare const binding: Readonly<BindingApi>;
-export {};

package/dist/application/binding.js

@@ -1,295 +0,0 @@
-import { queueRuntimeToken, validateSchema, } from '../core/index.js';
-import { assertValidCompilation, compileApplication } from '../graph/index.js';
-import { createHttpExecution, } from '../http/index.js';
-import { createMessagePortExecution, } from '../message-port/index.js';
-import { ApplicationRuntime, Logger } from '../runtime/index.js';
-import { bindQueueDriver } from './queue.js';
-import { matchesCronTrigger } from './scheduler.js';
-/** flatなcreateXXX/bindXXX APIを増殖させないため、外部bindingをnamespaceへ集約する。 */
-export const binding = Object.freeze({
-    invocation: createInvocationBinding,
-    host: createHostBinding,
-    queue: bindQueueDriver,
-});
-function createInvocationBinding(options) {
-    const state = createRuntimeState(options);
-    const application = createInvocationApplication(state);
-    return createProtocolBinding(state, application);
-}
-function createHostBinding(options) {
-    const state = createRuntimeState(options);
-    const application = createInvocationApplication(state);
-    let triggersStarted = false;
-    let triggerHandles = [];
-    const stopTriggers = async () => {
-        const handles = triggerHandles;
-        triggerHandles = [];
-        triggersStarted = false;
-        const results = await Promise.allSettled(handles.toReversed().map((handle) => handle.stop()));
-        const errors = results.flatMap((result) => result.status === 'rejected' ? [result.reason] : []);
-        if (errors.length > 0)
-            throw new AggregateError(errors, 'Trigger stop failed');
-    };
-    Object.assign(application, {
-        async close(signal) {
-            state.runtime.stopAcceptingExecutions();
-            const errors = [];
-            try {
-                await stopTriggers();
-            }
-            catch (error) {
-                errors.push(error);
-            }
-            try {
-                await state.runtime.shutdown(signal);
-            }
-            catch (error) {
-                errors.push(error);
-            }
-            if (errors.length > 0)
-                throw new AggregateError(errors, 'Application shutdown failed');
-        },
-        ...(state.definition.triggers.length > 0
-            ? {
-                triggers: {
-                    async start() {
-                        if (triggersStarted) {
-                            throw new Error('LUTRE_TRIGGERS_ALREADY_STARTED: Trigger Engine is already started.');
-                        }
-                        await state.runtime.initialize();
-                        triggersStarted = true;
-                        const started = [];
-                        try {
-                            for (const trigger of state.definition.triggers) {
-                                started.push(await startTrigger(trigger, state.runtime, state.logger));
-                            }
-                            triggerHandles = started;
-                        }
-                        catch (error) {
-                            await Promise.allSettled(started.toReversed().map((handle) => handle.stop()));
-                            triggersStarted = false;
-                            throw error;
-                        }
-                    },
-                    stop: stopTriggers,
-                },
-            }
-            : {}),
-    });
-    return createProtocolBinding(state, application);
-}
-function createRuntimeState(options) {
-    const definition = options.application;
-    const logger = definition.logger ?? new Logger();
-    const tasks = registeredTasks(definition);
-    const graph = assertValidCompilation(compileApplication({
-        modules: definition.modules,
-        ...(definition.arguments === undefined
-            ? {}
-            : { arguments: definition.arguments }),
-        tasks: definition.tasks,
-        triggers: definition.triggers,
-    }));
-    const runtime = new ApplicationRuntime(definition.modules, {
-        logger,
-        tasks,
-        publicTasks: definition.tasks,
-        ...(definition.arguments === undefined
-            ? {}
-            : {
-                arguments: definition.arguments,
-                argumentsSource: 'arguments' in options ? options.arguments : Object.freeze({}),
-            }),
-        ...('environment' in options
-            ? { environmentSource: options.environment }
-            : {}),
-    });
-    return { definition, logger, runtime, graph };
-}
-function createInvocationApplication(state) {
-    const application = {
-        graph: state.graph,
-        get(token) {
-            return state.runtime.get(token);
-        },
-        async init() {
-            await state.runtime.initialize();
-            return application;
-        },
-        ...(state.definition.tasks.length > 0
-            ? {
-                run(task, ...args) {
-                    return Reflect.apply(state.runtime.run, state.runtime, [
-                        task,
-                        ...args,
-                    ]);
-                },
-            }
-            : {}),
-        close: (signal) => state.runtime.shutdown(signal),
-    };
-    return application;
-}
-function createProtocolBinding(state, application) {
-    const protocols = new Set(state.graph.pipelines.map((pipeline) => pipeline.protocol));
-    return {
-        application,
-        ...(protocols.has('http')
-            ? {
-                http: createHttpExecution({
-                    runtime: state.runtime,
-                    graph: state.graph,
-                    logger: state.logger,
-                }),
-            }
-            : {}),
-        ...(protocols.has('messagePort')
-            ? {
-                messagePort: createMessagePortExecution({
-                    runtime: state.runtime,
-                    graph: state.graph,
-                    logger: state.logger,
-                }),
-            }
-            : {}),
-    };
-}
-async function startTrigger(trigger, runtime, logger) {
-    switch (trigger.trigger) {
-        case 'cron':
-            return startCronTrigger(trigger, runtime, logger);
-        case 'fixed-delay':
-            return startFixedDelayTrigger(trigger, runtime, logger);
-        case 'queue-consumer':
-            return startQueueTrigger(trigger, runtime);
-    }
-    throw new Error('LUTRE_TRIGGER_UNSUPPORTED: Unsupported trigger type.');
-}
-function startCronTrigger(trigger, runtime, logger) {
-    let stopped = false;
-    let lastMinute;
-    const active = new Set();
-    const tick = () => {
-        if (stopped)
-            return;
-        const now = new Date();
-        if (!matchesCronTrigger(trigger, now))
-            return;
-        const minute = cronMinuteIdentity(trigger.timezone, now);
-        if (lastMinute === minute)
-            return;
-        lastMinute = minute;
-        if (trigger.overlap === 'skip' && active.size > 0) {
-            logger.info('Cron trigger skipped overlapping execution', {
-                event: 'trigger.cron.skipped',
-                trigger: trigger.name,
-            });
-            return;
-        }
-        const execution = runtime.runTask(trigger.task).catch((error) => {
-            logger.error('Cron trigger execution failed', {
-                event: 'trigger.cron.execution.failed',
-                trigger: trigger.name,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        });
-        active.add(execution);
-        void execution.finally(() => active.delete(execution));
-    };
-    tick();
-    const timer = setInterval(tick, 1_000);
-    return {
-        async stop() {
-            if (stopped)
-                return;
-            stopped = true;
-            clearInterval(timer);
-            await Promise.allSettled(active);
-        },
-    };
-}
-function startFixedDelayTrigger(trigger, runtime, logger) {
-    let stopped = false;
-    let timer;
-    let releaseSleep;
-    const sleep = () => new Promise((resolve) => {
-        releaseSleep = resolve;
-        timer = setTimeout(() => {
-            timer = undefined;
-            releaseSleep = undefined;
-            resolve();
-        }, trigger.delay);
-    });
-    const execute = async () => {
-        try {
-            await runtime.runTask(trigger.task);
-        }
-        catch (error) {
-            logger.error('Fixed-delay trigger execution failed', {
-                event: 'trigger.fixed_delay.execution.failed',
-                trigger: trigger.name,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    };
-    const loop = (async () => {
-        if (!trigger.immediate)
-            await sleep();
-        while (true) {
-            if (stopped)
-                break;
-            await execute();
-            if (stopped)
-                break;
-            await sleep();
-        }
-    })();
-    return {
-        async stop() {
-            if (stopped)
-                return;
-            stopped = true;
-            if (timer)
-                clearTimeout(timer);
-            timer = undefined;
-            releaseSleep?.();
-            releaseSleep = undefined;
-            await loop;
-        },
-    };
-}
-async function startQueueTrigger(trigger, runtime) {
-    const driver = runtime.container.resolve(queueRuntimeToken(trigger.queue));
-    if (!driver || typeof driver.start !== 'function') {
-        throw new Error(`LUTRE_QUEUE_DRIVER_INVALID: Queue ${trigger.queue.name} driver is invalid.`);
-    }
-    const handle = await driver.start({
-        consume: async (payload) => {
-            const validated = await validateSchema(trigger.queue.payload, payload);
-            await runtime.runTask(trigger.task, validated);
-        },
-    });
-    if (!handle || typeof handle.stop !== 'function') {
-        throw new Error(`LUTRE_QUEUE_DRIVER_INVALID: Queue ${trigger.queue.name} driver returned an invalid handle.`);
-    }
-    return handle;
-}
-function registeredTasks(definition) {
-    return [
-        ...new Set([
-            ...definition.tasks,
-            ...definition.triggers.map((trigger) => trigger.task),
-        ]),
-    ];
-}
-function cronMinuteIdentity(timezone, instant) {
-    return new Intl.DateTimeFormat('en-CA', {
-        timeZone: timezone,
-        year: 'numeric',
-        month: '2-digit',
-        day: '2-digit',
-        hour: '2-digit',
-        minute: '2-digit',
-        hourCycle: 'h23',
-    }).format(instant);
-}

package/dist/application/host.d.ts

@@ -1,8 +0,0 @@
-import type { ApplicationDefinition, BootstrapArguments, HostedApplication } from './index.js';
-export interface BootstrapBaseOptions<TDefinition extends ApplicationDefinition> {
-    readonly application: TDefinition;
-    readonly environment?: unknown;
-}
-export type BootstrapOptions<TDefinition extends ApplicationDefinition> = BootstrapBaseOptions<TDefinition> & BootstrapArguments<TDefinition>;
-/** generic hostへruntime固有listenerを持ち込まないため、listener ownershipはruntime adapterへ委ねる。 */
-export declare function bootstrap<const TDefinition extends ApplicationDefinition>(options: BootstrapOptions<TDefinition>): HostedApplication<TDefinition>;

package/dist/application/host.js

@@ -1,14 +0,0 @@
-import { binding } from './binding.js';
-/** generic hostへruntime固有listenerを持ち込まないため、listener ownershipはruntime adapterへ委ねる。 */
-export function bootstrap(options) {
-    const host = binding.host(options);
-    const http = 'http' in host ? host.http : undefined;
-    if (http) {
-        Object.assign(host.application, {
-            fetch(request) {
-                return http.handle(request);
-            },
-        });
-    }
-    return host.application;
-}

package/dist/application/queue.d.ts

@@ -1,3 +0,0 @@
-import { type ProviderDescriptor, type QueueDescriptor } from '../core/index.js';
-import type { QueueConsumerDriver } from './index.js';
-export declare function bindQueueDriver(queue: QueueDescriptor, driver: QueueConsumerDriver): ProviderDescriptor;

package/dist/application/queue.js

@@ -1,4 +0,0 @@
-import { provide, queueRuntimeToken, } from '../core/index.js';
-export function bindQueueDriver(queue, driver) {
-    return provide(queueRuntimeToken(queue)).useValue(driver);
-}

package/dist/application/scheduler.d.ts

@@ -1,2 +0,0 @@
-import type { CronTriggerDescriptor } from '../core/index.js';
-export declare function matchesCronTrigger(trigger: CronTriggerDescriptor<any>, instant: Date): boolean;

package/dist/application/scheduler.js

@@ -1,45 +0,0 @@
-export function matchesCronTrigger(trigger, instant) {
-    const [minute, hour, dayOfMonth, month, dayOfWeek] = trigger.expression
-        .trim()
-        .split(/\s+/);
-    const fields = { minute, hour, dayOfMonth, month, dayOfWeek };
-    const parts = new Intl.DateTimeFormat('en-US', {
-        timeZone: trigger.timezone,
-        minute: 'numeric',
-        hour: 'numeric',
-        day: 'numeric',
-        month: 'numeric',
-        weekday: 'short',
-        hourCycle: 'h23',
-    }).formatToParts(instant);
-    const value = (type) => parts.find((part) => part.type === type)?.value ?? '';
-    const weekday = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'].indexOf(value('weekday'));
-    return (matchesCronField(fields.minute, Number(value('minute')), 0, 59) &&
-        matchesCronField(fields.hour, Number(value('hour')), 0, 23) &&
-        matchesCronField(fields.dayOfMonth, Number(value('day')), 1, 31) &&
-        matchesCronField(fields.month, Number(value('month')), 1, 12) &&
-        matchesCronField(fields.dayOfWeek, weekday, 0, 7, true));
-}
-function matchesCronField(expression, value, minimum, maximum, sundayAlias = false) {
-    return expression.split(',').some((segment) => {
-        const [rangeExpression, stepExpression] = segment.split('/');
-        const step = stepExpression === undefined ? 1 : Number(stepExpression);
-        if (!Number.isInteger(step) || step <= 0 || !rangeExpression)
-            return false;
-        let start = minimum;
-        let end = maximum;
-        if (rangeExpression !== '*') {
-            const [startExpression, endExpression] = rangeExpression.split('-');
-            start = Number(startExpression);
-            end = endExpression === undefined ? start : Number(endExpression);
-        }
-        const normalized = sundayAlias && value === 0 && start === 7 ? 7 : value;
-        return (Number.isInteger(start) &&
-            Number.isInteger(end) &&
-            start >= minimum &&
-            end <= maximum &&
-            normalized >= start &&
-            normalized <= end &&
-            (normalized - start) % step === 0);
-    });
-}

package/dist/core/context-key.d.ts

@@ -1,16 +0,0 @@
-export interface ContextKey<TName extends string = string, TValue = unknown> {
-    readonly kind: 'context-key';
-    readonly name: TName;
-    readonly key: symbol;
-    readonly '~value'?: TValue;
-}
-export type ContextKeyValue<TKey> = TKey extends ContextKey<string, infer TValue> ? TValue : never;
-export type ContextProperties<TKeys extends readonly ContextKey[]> = {
-    readonly [TKey in TKeys[number] as TKey['name']]: ContextKeyValue<TKey>;
-};
-type ContextKeyNameConstraint<TName extends string> = TName extends '' | '__proto__' ? never : unknown;
-export declare function contextKey<const TName extends string>(name: TName & ContextKeyNameConstraint<TName>): {
-    of<TValue>(): ContextKey<TName, TValue>;
-};
-export declare function contextKeyName(key: ContextKey): string;
-export {};

package/dist/core/context-key.js

@@ -1,17 +0,0 @@
-export function contextKey(name) {
-    if (name.length === 0 || name === '__proto__') {
-        throw new Error(`Invalid Context Key name: ${JSON.stringify(name)}`);
-    }
-    return {
-        of() {
-            return Object.freeze({
-                kind: 'context-key',
-                name,
-                key: Symbol(name),
-            });
-        },
-    };
-}
-export function contextKeyName(key) {
-    return key.name;
-}

package/dist/core/contract-internal.d.ts

@@ -1,22 +0,0 @@
-import type { ContractDefinition } from './contract.js';
-export declare const protocolNamespaceBuilder: unique symbol;
-export declare const protocolNamespaceType: unique symbol;
-export declare const contractNodeBinding: unique symbol;
-export declare const contractNodeKindType: unique symbol;
-export declare const contractNodeMetadata: unique symbol;
-export interface ContractNodeMetadata {
-    readonly kind: 'leaf' | 'branch';
-    readonly root: ContractDefinition;
-    readonly path: readonly string[];
-    readonly procedures: Readonly<Record<string, string>>;
-}
-export declare function contractNodeMetadataOf(contract: ContractDefinition): ContractNodeMetadata | undefined;
-export declare function contractRootOf(contract: ContractDefinition): ContractDefinition;
-export declare function contractProcedurePathOf(contract: ContractDefinition, procedure: string): string;
-export interface ContractProcedureIdentity {
-    readonly contract: ContractDefinition;
-    readonly procedure: string;
-}
-export declare function resolveContractProcedureIdentity(contract: ContractDefinition, procedure: string, applicationContract?: ContractDefinition): ContractProcedureIdentity;
-export declare function contractNodePathOf(contract: ContractDefinition): readonly string[] | undefined;
-export declare function contractOfBinding(value: unknown): ContractDefinition;

package/dist/core/contract-internal.js

@@ -1,61 +0,0 @@
-export const protocolNamespaceBuilder = Symbol('loutre.protocol-namespace-builder');
-export const protocolNamespaceType = Symbol('loutre.protocol-namespace-type');
-export const contractNodeBinding = Symbol.for('loutre.contract-node-binding');
-export const contractNodeKindType = Symbol('loutre.contract-node-kind-type');
-export const contractNodeMetadata = Symbol.for('loutre.contract-node-metadata');
-export function contractNodeMetadataOf(contract) {
-    return contractNodeMetadata in contract
-        ? contract[contractNodeMetadata]
-        : undefined;
-}
-export function contractRootOf(contract) {
-    return contractNodeMetadata in contract
-        ? contract[contractNodeMetadata].root
-        : contract;
-}
-export function contractProcedurePathOf(contract, procedure) {
-    if (!(contractNodeMetadata in contract))
-        return procedure;
-    return (contract[contractNodeMetadata].procedures[procedure] ?? procedure);
-}
-export function resolveContractProcedureIdentity(contract, procedure, applicationContract) {
-    if (applicationContract && contract === applicationContract) {
-        return { contract: applicationContract, procedure };
-    }
-    const canonicalProcedure = contractProcedurePathOf(contract, procedure);
-    if (applicationContract) {
-        const applicationNode = contractNodeMetadataOf(applicationContract);
-        const implementationNode = contractNodeMetadataOf(contract);
-        if (applicationNode &&
-            implementationNode &&
-            applicationNode.root === implementationNode.root &&
-            isContractNodePathPrefix(applicationNode.path, implementationNode.path)) {
-            const prefix = applicationNode.path.slice(1).join('.');
-            const relativeProcedure = canonicalProcedure.startsWith(`${prefix}.`)
-                ? canonicalProcedure.slice(prefix.length + 1)
-                : canonicalProcedure;
-            return { contract: applicationContract, procedure: relativeProcedure };
-        }
-    }
-    return {
-        contract: contractRootOf(contract),
-        procedure: canonicalProcedure,
-    };
-}
-function isContractNodePathPrefix(prefix, candidate) {
-    return (prefix.length <= candidate.length &&
-        prefix.every((segment, index) => candidate[index] === segment));
-}
-export function contractNodePathOf(contract) {
-    return contractNodeMetadata in contract
-        ? contract[contractNodeMetadata].path
-        : undefined;
-}
-export function contractOfBinding(value) {
-    if (typeof value === 'object' &&
-        value !== null &&
-        contractNodeBinding in value) {
-        return value[contractNodeBinding];
-    }
-    return value;
-}