@loutrejs/loutre 0.4.1 → 0.6.0

package/dist/runtime/application.js

@@ -1,339 +0,0 @@
-import { argumentsProvider, loadArgs, loadEnv, normalizeProvider, } from '../core/index.js';
-import { collectRuntimeModuleGraph, Container, } from './di.js';
-import { Logger } from './logger.js';
-const NO_ENVIRONMENT_SOURCE = Symbol('loutre.no-environment-source');
-let currentEnvironmentSource = NO_ENVIRONMENT_SOURCE;
-export function initializeWithEnvironment(application, environmentSource) {
-    const previous = currentEnvironmentSource;
-    currentEnvironmentSource = environmentSource;
-    try {
-        return application.initialize();
-    }
-    finally {
-        currentEnvironmentSource = previous;
-    }
-}
-export class EnvironmentBindingError extends Error {
-    code = 'LUTRE_ENV_003';
-    constructor(environment, cause) {
-        super(`Environment validation failed for ${environment.name}.`, { cause });
-        this.name = 'EnvironmentBindingError';
-    }
-}
-export class ArgumentsBindingError extends Error {
-    code = 'LUTRE_ARGS_003';
-    constructor(argumentsContract, cause) {
-        super(`Arguments validation failed for ${argumentsContract.name}.`, {
-            cause,
-        });
-        this.name = 'ArgumentsBindingError';
-    }
-}
-export class ApplicationRuntime {
-    graph;
-    container;
-    #instancesByModule = new Map();
-    #logger;
-    #environmentSource;
-    #arguments;
-    #argumentsSource;
-    #tasks;
-    #publicTasks;
-    #initialized = false;
-    #initializing;
-    #prepared = false;
-    #state = 'created';
-    #activeExecutions = 0;
-    #idleWaiters = new Set();
-    #shutdown;
-    constructor(roots, options = {}) {
-        this.#logger = options.logger ?? new Logger();
-        this.#environmentSource =
-            'environmentSource' in options
-                ? options.environmentSource
-                : NO_ENVIRONMENT_SOURCE;
-        this.#arguments = options.arguments;
-        this.#argumentsSource =
-            'argumentsSource' in options ? options.argumentsSource : Object.freeze({});
-        this.#tasks = new Set(options.tasks ?? []);
-        this.#publicTasks = new Set(options.publicTasks ?? []);
-        this.graph = collectRuntimeModuleGraph(roots);
-        const providers = [
-            ...this.graph.providers,
-            ...(this.#arguments ? [argumentsProvider(this.#arguments)] : []),
-        ];
-        this.container = new Container(providers, {
-            logger: this.#logger,
-        });
-    }
-    initialize() {
-        if (this.#initialized)
-            return Promise.resolve();
-        if (this.#initializing)
-            return this.#initializing;
-        if (this.#state === 'stopping') {
-            return Promise.reject(applicationStateError('LUTRE_APP_STOPPING'));
-        }
-        if (this.#state === 'stopped') {
-            return Promise.reject(applicationStateError('LUTRE_APP_STOPPED'));
-        }
-        const source = this.#environmentSource === NO_ENVIRONMENT_SOURCE
-            ? currentEnvironmentSource
-            : this.#environmentSource;
-        const initialization = this.#initialize(source).finally(() => {
-            if (this.#initializing === initialization) {
-                this.#initializing = undefined;
-            }
-        });
-        this.#initializing = initialization;
-        return initialization;
-    }
-    async #initialize(environmentSource) {
-        this.#state = 'initializing';
-        try {
-            await this.#bindEnvironment(environmentSource);
-            await this.#bindArguments();
-            this.#prepareRuntime();
-            for (const module of this.graph.modules) {
-                const instances = await this.#resolveModuleProviders(module);
-                this.#instancesByModule.set(module, instances);
-                for (const instance of instances)
-                    await callLifecycle(instance, 'onModuleInit');
-                await this.#runHook(module.definition.lifecycle?.onModuleInit);
-            }
-            for (const module of this.graph.modules) {
-                for (const instance of this.#instancesByModule.get(module) ?? []) {
-                    await callLifecycle(instance, 'onApplicationBootstrap');
-                }
-                await this.#runHook(module.definition.lifecycle?.onApplicationBootstrap);
-            }
-            this.#initialized = true;
-            if (this.#state !== 'stopping')
-                this.#state = 'running';
-        }
-        catch (error) {
-            const cleanupErrors = await this.#rollbackInitialization();
-            this.#state = 'stopped';
-            if (cleanupErrors.length > 0) {
-                throw new AggregateError([error, ...cleanupErrors], 'Application initialization failed and rollback cleanup also failed', { cause: error });
-            }
-            throw error;
-        }
-    }
-    async #bindEnvironment(source) {
-        const environmentProviders = this.graph.providers.filter((provider) => provider.kind === 'environment');
-        if (environmentProviders.length === 0)
-            return;
-        if (source === NO_ENVIRONMENT_SOURCE) {
-            throw new Error('LUTRE_ENV_005: Application declares Environment Contracts, but the Runtime did not provide an Environment source.');
-        }
-        for (const provider of environmentProviders) {
-            try {
-                const value = await loadEnv(provider.provide, source);
-                this.container.bindEnvironment(provider.provide, value);
-            }
-            catch (error) {
-                throw new EnvironmentBindingError(provider.provide, error);
-            }
-        }
-    }
-    async #bindArguments() {
-        if (!this.#arguments)
-            return;
-        try {
-            const value = await loadArgs(this.#arguments, this.#argumentsSource);
-            this.container.bindArguments(this.#arguments, value);
-        }
-        catch (error) {
-            throw new ArgumentsBindingError(this.#arguments, error);
-        }
-    }
-    #prepareRuntime() {
-        if (this.#prepared)
-            return;
-        for (const module of this.graph.modules) {
-            for (const implementation of module.definition.implementations ?? []) {
-                this.container.prepareImplementation(implementation);
-            }
-        }
-        for (const pipeline of collectApplicationPipelines(this.graph.modules)) {
-            this.container.preparePipeline(pipeline);
-        }
-        for (const task of this.#tasks) {
-            this.container.prepareTask(task);
-        }
-        this.#prepared = true;
-    }
-    get(token) {
-        if (this.#state === 'created' || this.#state === 'initializing') {
-            throw applicationStateError('LUTRE_APP_NOT_INITIALIZED');
-        }
-        if (this.#state === 'stopping') {
-            throw applicationStateError('LUTRE_APP_STOPPING');
-        }
-        if (this.#state === 'stopped') {
-            throw applicationStateError('LUTRE_APP_STOPPED');
-        }
-        return this.container.get(token);
-    }
-    run(task, ...args) {
-        if (!this.#publicTasks.has(task)) {
-            return Promise.reject(new Error(`LUTRE_TASK_002: Task ${task.name} is not registered in Application.tasks.`));
-        }
-        return this.#invokeTask(task, args);
-    }
-    /** public run()ではTrigger専用Taskを拒否するため、Trigger Host専用経路を分ける。 */
-    runTask(task, ...args) {
-        if (!this.#tasks.has(task)) {
-            return Promise.reject(new Error(`LUTRE_TASK_NOT_REGISTERED: Task ${task.name} is not registered in this Application.`));
-        }
-        return this.#invokeTask(task, args);
-    }
-    #invokeTask(task, args) {
-        return this.execute(async () => {
-            const runtime = this.container.taskRuntime(task);
-            return Reflect.apply(runtime, undefined, args);
-        });
-    }
-    async execute(execution) {
-        if (this.#state === 'stopping')
-            throw applicationStateError('LUTRE_APP_STOPPING');
-        if (this.#state === 'stopped')
-            throw applicationStateError('LUTRE_APP_STOPPED');
-        this.#activeExecutions += 1;
-        try {
-            await this.initialize();
-            return await execution();
-        }
-        finally {
-            this.#activeExecutions -= 1;
-            if (this.#activeExecutions === 0) {
-                for (const resolve of this.#idleWaiters)
-                    resolve();
-                this.#idleWaiters.clear();
-            }
-        }
-    }
-    stopAcceptingExecutions() {
-        if (this.#state !== 'stopped')
-            this.#state = 'stopping';
-    }
-    shutdown(signal) {
-        if (this.#state === 'stopped')
-            return Promise.resolve();
-        if (this.#shutdown)
-            return this.#shutdown;
-        this.stopAcceptingExecutions();
-        const shutdown = this.#shutdownRuntime(signal);
-        this.#shutdown = shutdown;
-        return shutdown;
-    }
-    async #shutdownRuntime(signal) {
-        if (this.#initializing) {
-            await this.#initializing.catch(() => undefined);
-        }
-        if (this.#activeExecutions > 0) {
-            await new Promise((resolve) => this.#idleWaiters.add(resolve));
-        }
-        const errors = [];
-        const modules = this.graph.modules.toReversed();
-        try {
-            for (const module of modules) {
-                for (const instance of (this.#instancesByModule.get(module) ?? []).toReversed()) {
-                    await collectCleanupError(() => callLifecycle(instance, 'onModuleDestroy'), errors);
-                }
-                await collectCleanupError(() => this.#runHook(module.definition.lifecycle?.onModuleDestroy), errors);
-            }
-            for (const module of modules) {
-                for (const instance of (this.#instancesByModule.get(module) ?? []).toReversed()) {
-                    await collectCleanupError(() => callLifecycle(instance, 'beforeApplicationShutdown', signal), errors);
-                }
-                await collectCleanupError(() => this.#runHook(module.definition.lifecycle?.beforeApplicationShutdown), errors);
-            }
-            for (const module of modules) {
-                for (const instance of (this.#instancesByModule.get(module) ?? []).toReversed()) {
-                    await collectCleanupError(() => callLifecycle(instance, 'onApplicationShutdown', signal), errors);
-                }
-                await collectCleanupError(() => this.#runHook(module.definition.lifecycle?.onApplicationShutdown), errors);
-            }
-        }
-        finally {
-            this.#state = 'stopped';
-        }
-        if (errors.length > 0) {
-            throw new AggregateError(errors, 'Application shutdown cleanup failed');
-        }
-    }
-    async #rollbackInitialization() {
-        const errors = [];
-        const modules = [...this.#instancesByModule.keys()].toReversed();
-        for (const module of modules) {
-            await collectCleanupError(() => this.#runHook(module.definition.lifecycle?.onModuleDestroy), errors);
-            for (const instance of (this.#instancesByModule.get(module) ?? []).toReversed()) {
-                await collectCleanupError(() => callLifecycle(instance, 'onModuleDestroy'), errors);
-            }
-        }
-        return errors;
-    }
-    async #resolveModuleProviders(module) {
-        const providers = (module.definition.providers ?? []).map(normalizeProvider);
-        const applicationProviders = providers.filter((provider) => provider.scope === 'application' &&
-            provider.kind !== 'environment' &&
-            provider.kind !== 'arguments');
-        const instances = [];
-        this.#instancesByModule.set(module, instances);
-        for (const provider of applicationProviders) {
-            instances.push(this.container.resolve(provider.provide));
-        }
-        return instances;
-    }
-    async #runHook(hook) {
-        if (!hook)
-            return;
-        const dependencies = hook.inject.map((token) => this.container.resolve(token));
-        await hook.run(...dependencies);
-    }
-}
-function applicationStateError(code) {
-    const message = code === 'LUTRE_APP_NOT_INITIALIZED'
-        ? 'Application is not initialized.'
-        : code === 'LUTRE_APP_STOPPING'
-            ? 'Application is stopping and cannot accept new executions.'
-            : 'Application is stopped and cannot accept new executions.';
-    return new Error(`${code}: ${message}`);
-}
-function collectApplicationPipelines(modules) {
-    const pipelines = [];
-    for (const module of modules) {
-        for (const implementation of module.definition.implementations ?? []) {
-            for (const procedureName of implementation.procedures) {
-                const procedure = implementation.contract.procedures[procedureName];
-                const protocol = procedure?.protocols[implementation.protocol];
-                const pipeline = protocol?.pipeline ?? protocol?.definition?.pipeline;
-                if (pipeline)
-                    pipelines.push(pipeline);
-            }
-        }
-    }
-    return pipelines;
-}
-async function collectCleanupError(cleanup, errors) {
-    try {
-        await cleanup();
-    }
-    catch (error) {
-        errors.push(error);
-    }
-}
-export function createApplicationRuntime(roots, options = {}) {
-    return new ApplicationRuntime(roots, options);
-}
-async function callLifecycle(instance, method, signal) {
-    if (!instance ||
-        (typeof instance !== 'object' && typeof instance !== 'function'))
-        return;
-    const candidate = instance[method];
-    if (typeof candidate !== 'function')
-        return;
-    await Reflect.apply(candidate, instance, signal === undefined ? [] : [signal]);
-}

package/dist/runtime/pipeline.d.ts

@@ -1,11 +0,0 @@
-import { type LayerDescriptor, type LayerRuntime, type PipelineItem, type TerminalLayerDescriptor, type ValidationLayerDescriptor } from '../core/index.js';
-export interface PipelineHooks<TContext extends object, TResult> {
-    readonly context: TContext;
-    readonly validate: (layer: ValidationLayerDescriptor, context: TContext) => void | Promise<void>;
-    readonly terminal: (layer: TerminalLayerDescriptor, context: TContext) => TResult | Promise<TResult>;
-    readonly layer: (descriptor: LayerDescriptor) => LayerRuntime<object, readonly [], unknown>;
-}
-export declare class LayerContractError extends Error {
-    constructor(message: string);
-}
-export declare function executePipeline<TContext extends object, TResult>(pipeline: readonly PipelineItem[], hooks: PipelineHooks<TContext, TResult>): Promise<TResult>;

package/dist/runtime/pipeline.js

@@ -1,161 +0,0 @@
-import { childPipelineOf, contextKeyName, isShortCircuit, layerDefinitionOf, } from '../core/index.js';
-export class LayerContractError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'LayerContractError';
-    }
-}
-export async function executePipeline(pipeline, hooks) {
-    const context = hooks.context;
-    const flow = await executeSegment(pipeline, 0, hooks, context, new Set());
-    if (flow.kind === 'continue') {
-        throw new Error('Pipeline did not produce a result');
-    }
-    return flow.result;
-}
-async function executeSegment(pipeline, index, hooks, context, availableKeys) {
-    const item = pipeline[index];
-    if (!item)
-        return { kind: 'continue' };
-    if (item.kind === 'validation') {
-        await hooks.validate(item, context);
-        return executeSegment(pipeline, index + 1, hooks, context, availableKeys);
-    }
-    if (item.kind === 'terminal') {
-        return {
-            kind: 'complete',
-            result: await hooks.terminal(item, context),
-        };
-    }
-    const definition = layerDefinitionOf(item);
-    assertRequiredContext(definition.name, definition.requires, availableKeys);
-    const child = childPipelineOf(item);
-    const continuation = child === undefined
-        ? () => executeSegment(pipeline, index + 1, hooks, context, availableKeys)
-        : () => executeSegment(child, 0, hooks, context, availableKeys);
-    const flow = await executeLayer(definition, hooks.layer(definition), continuation, context, availableKeys);
-    if (flow.kind === 'complete' || child === undefined)
-        return flow;
-    return executeSegment(pipeline, index + 1, hooks, context, availableKeys);
-}
-async function executeLayer(layer, runtime, continuation, context, availableKeys) {
-    let calls = 0;
-    let continuationFlow = { kind: 'continue' };
-    let continuationFailed = false;
-    let continuationError;
-    let contractError;
-    let completion;
-    const next = (...arguments_) => {
-        calls += 1;
-        if (calls > 1) {
-            contractError = new LayerContractError(`LUTRE_LAYER_NEXT_REENTRY: Layer ${layer.name} can call next() only once`);
-            return Promise.reject(contractError);
-        }
-        applyProvidedContext(layer, context, availableKeys, arguments_);
-        completion = (async () => {
-            try {
-                continuationFlow = await continuation();
-            }
-            catch (error) {
-                continuationFailed = true;
-                continuationError = error;
-                throw error;
-            }
-        })();
-        return completion;
-    };
-    let runtimeResult;
-    let runtimeError;
-    let runtimeFailed = false;
-    try {
-        runtimeResult = await Reflect.apply(runtime, undefined, [context, next]);
-    }
-    catch (error) {
-        runtimeFailed = true;
-        runtimeError = error;
-    }
-    if (completion) {
-        try {
-            await completion;
-        }
-        catch {
-            // continuation failureはLayerが握り潰しても下で元の値を再throwする。
-        }
-    }
-    if (continuationFailed)
-        throw continuationError;
-    if (contractError)
-        throw contractError;
-    if (runtimeFailed)
-        throw runtimeError;
-    if (isShortCircuit(runtimeResult)) {
-        if (calls > 0) {
-            throw new LayerContractError(`LUTRE_LAYER_SHORT_CIRCUIT_AFTER_NEXT: Layer ${layer.name} cannot shortCircuit after next()`);
-        }
-        return {
-            kind: 'complete',
-            result: runtimeResult.result,
-        };
-    }
-    if (calls === 0) {
-        throw new LayerContractError(`LUTRE_LAYER_NEXT_SKIPPED: Layer ${layer.name} must call next() exactly once`);
-    }
-    return continuationFlow;
-}
-function assertRequiredContext(layerName, requiredKeys, availableKeys) {
-    for (const required of requiredKeys) {
-        if (!availableKeys.has(required)) {
-            throw new LayerContractError(`Context Key ${contextKeyName(required)} required by ${layerName} is unavailable`);
-        }
-    }
-}
-function applyProvidedContext(layer, context, availableKeys, arguments_) {
-    if (arguments_.length > 1) {
-        throw new LayerContractError(`Layer ${layer.name} can pass only one Context object to next()`);
-    }
-    if (layer.provides.length === 0) {
-        if (arguments_.length > 0) {
-            const provided = arguments_[0];
-            const property = firstProperty(provided);
-            throw new LayerContractError(property === undefined
-                ? `Layer ${layer.name} does not declare any provided Context`
-                : `Layer ${layer.name} provided undeclared Context property ${property}`);
-        }
-        return;
-    }
-    const provided = arguments_[0];
-    if (typeof provided !== 'object' ||
-        provided === null ||
-        Array.isArray(provided)) {
-        throw new LayerContractError(`Layer ${layer.name} must pass its declared Context to next(object)`);
-    }
-    const additions = provided;
-    const declaredNames = new Set(layer.provides.map((key) => key.name));
-    for (const property of Object.keys(additions)) {
-        if (!declaredNames.has(property)) {
-            throw new LayerContractError(`Layer ${layer.name} provided undeclared Context property ${property}`);
-        }
-    }
-    const providedNames = new Set();
-    for (const key of layer.provides) {
-        if (providedNames.has(key.name)) {
-            throw new LayerContractError(`Layer ${layer.name} declared duplicate Context property ${key.name}`);
-        }
-        providedNames.add(key.name);
-        if (!Object.hasOwn(additions, key.name)) {
-            throw new LayerContractError(`Layer ${layer.name} did not provide declared Context Key ${contextKeyName(key)}`);
-        }
-        if (Object.hasOwn(context, key.name)) {
-            throw new LayerContractError(`Layer ${layer.name} cannot overwrite existing Context property ${key.name}`);
-        }
-    }
-    Object.assign(context, additions);
-    for (const key of layer.provides)
-        availableKeys.add(key);
-}
-function firstProperty(value) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-        return undefined;
-    }
-    return Object.keys(value)[0];
-}