@loutrejs/loutre 0.3.0 → 0.4.1

package/dist/adapters/bun.d.ts

@@ -1,22 +1,25 @@
 import { type ApplicationDefinition, type BootstrapArguments, type HasHttp, type HostBindingApplication } from '../application/index.js';
 type IsAny<TValue> = 0 extends 1 & TValue ? true : false;
 type HttpApplication<TDefinition extends ApplicationDefinition> = IsAny<TDefinition> extends true ? TDefinition : HasHttp<TDefinition> extends true ? TDefinition : never;
-export type BunServeOptions<TDefinition extends ApplicationDefinition> = {
+export type BunCreateOptions<TDefinition extends ApplicationDefinition> = {
     readonly application: HttpApplication<TDefinition>;
+    readonly environment?: unknown;
+} & BootstrapArguments<TDefinition>;
+export interface BunServeOptions {
     readonly port?: number;
     readonly hostname?: string;
     readonly shutdownHooks?: boolean;
-    readonly environment?: unknown;
-} & BootstrapArguments<TDefinition>;
-export interface BunServeHandle<TDefinition extends ApplicationDefinition = ApplicationDefinition> {
-    readonly application: HostBindingApplication<TDefinition>;
+}
+export interface BunListenerHandle {
     readonly port: number;
-    close(signal?: string): Promise<void>;
 }
+export type BunRuntimeApplication<TDefinition extends ApplicationDefinition = ApplicationDefinition> = HostBindingApplication<TDefinition> & {
+    serve(options?: BunServeOptions): Promise<BunListenerHandle>;
+};
 export declare const bunRuntime: {
     readonly runtime: 'bun';
     readonly capabilities: Set<string>;
-    readonly serve: typeof serve;
+    readonly create: typeof create;
 };
-declare function serve<const TDefinition extends ApplicationDefinition>(options: BunServeOptions<TDefinition>): Promise<BunServeHandle<TDefinition>>;
+declare function create<const TDefinition extends ApplicationDefinition>(options: BunCreateOptions<TDefinition>): Promise<BunRuntimeApplication<TDefinition>>;
 export {};

package/dist/adapters/bun.js

@@ -15,16 +15,13 @@ export const bunRuntime = {
         'env.runtime',
         'crypto.random',
     ]),
-    serve,
+    create,
 };
-async function serve(options) {
+async function create(options) {
     assertRuntimeEngine('bun');
     const bun = bunGlobal();
-    if (!bun?.serve) {
-        throw new Error('LUTRE_BUN_UNAVAILABLE: Bun.serve() is not available.');
-    }
     const startedAt = performance.now();
-    const environment = bun.env ?? {};
+    const environment = bun?.env ?? {};
     const presentation = startStartupPresentation({ version: LOUTRE_VERSION }, {
         terminal: detectPresentationTerminal(process.stdout, environment),
         write: (value) => console.log(value),
@@ -37,53 +34,32 @@ async function serve(options) {
     const http = 'http' in host ? host.http : undefined;
     if (!http) {
         await host.application.close();
-        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: bunRuntime.serve() requires an HTTP-capable Application.');
+        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: bunRuntime.create() requires an HTTP-capable Application.');
     }
     await host.application.init();
-    if ('triggers' in host.application)
-        await host.application.triggers.start();
+    const application = host.application;
+    const closeApplication = host.application.close.bind(host.application);
     let server;
-    const requestedPort = options.port;
-    let port = requestedPort ?? 3000;
-    while (true) {
-        try {
-            server = bun.serve({
-                port,
-                ...(options.hostname === undefined
-                    ? {}
-                    : { hostname: options.hostname }),
-                fetch: createBunFetchDriver(http),
-            });
-            break;
-        }
-        catch (error) {
-            if (requestedPort !== undefined || !canRetryOnNextPort(error, port)) {
-                await host.application.close().catch(() => undefined);
-                throw error;
-            }
-            port += 1;
-        }
-    }
-    presentation.ready({
-        server: serverUrl(options.hostname, port),
-        runtime: `Bun ${bun.version ?? 'unknown'}`,
-        environment: environment.NODE_ENV ?? 'development',
-        startupDurationMs: performance.now() - startedAt,
-    });
+    let removeShutdownHooks;
+    let serving = false;
     let closed = false;
-    const closeRuntime = async (signal) => {
+    const close = async (signal) => {
         if (closed)
             return;
         closed = true;
+        removeShutdownHooks?.();
+        removeShutdownHooks = undefined;
         const errors = [];
-        try {
-            await server.stop(true);
-        }
-        catch (error) {
-            errors.push(error);
+        if (server) {
+            try {
+                await server.stop(true);
+            }
+            catch (error) {
+                errors.push(error);
+            }
         }
         try {
-            await host.application.close(signal);
+            await closeApplication(signal);
         }
         catch (error) {
             errors.push(error);
@@ -91,14 +67,60 @@ async function serve(options) {
         if (errors.length > 0)
             throw new AggregateError(errors, 'Bun runtime shutdown failed');
     };
-    const removeShutdownHooks = options.shutdownHooks === false
-        ? undefined
-        : registerBunShutdownHooks(closeRuntime);
-    const close = async (signal) => {
-        removeShutdownHooks?.();
-        await closeRuntime(signal);
+    const serve = async (serveOptions = {}) => {
+        if (closed) {
+            throw new Error('LUTRE_APP_STOPPED: Application is stopped.');
+        }
+        if (serving) {
+            throw new Error('LUTRE_RUNTIME_ALREADY_SERVING: Bun runtime Application is already serving.');
+        }
+        if (!bun?.serve) {
+            await close().catch(() => undefined);
+            throw new Error('LUTRE_BUN_UNAVAILABLE: Bun.serve() is not available.');
+        }
+        serving = true;
+        try {
+            if ('triggers' in application)
+                await application.triggers.start();
+            const requestedPort = serveOptions.port;
+            let port = requestedPort ?? 3000;
+            while (true) {
+                try {
+                    server = bun.serve({
+                        port,
+                        ...(serveOptions.hostname === undefined
+                            ? {}
+                            : { hostname: serveOptions.hostname }),
+                        fetch: createBunFetchDriver(http),
+                    });
+                    break;
+                }
+                catch (error) {
+                    if (requestedPort !== undefined || !canRetryOnNextPort(error, port)) {
+                        throw error;
+                    }
+                    port += 1;
+                }
+            }
+            presentation.ready({
+                server: serverUrl(serveOptions.hostname, port),
+                runtime: `Bun ${bun.version ?? 'unknown'}`,
+                environment: environment.NODE_ENV ?? 'development',
+                startupDurationMs: performance.now() - startedAt,
+            });
+            removeShutdownHooks =
+                serveOptions.shutdownHooks === false
+                    ? undefined
+                    : registerBunShutdownHooks(close);
+            return { port };
+        }
+        catch (error) {
+            await close().catch(() => undefined);
+            throw error;
+        }
     };
-    return { application: host.application, port, close };
+    Object.assign(application, { serve, close });
+    return application;
 }
 function registerBunShutdownHooks(close) {
     const handlers = new Map();

package/dist/adapters/deno.d.ts

@@ -5,26 +5,28 @@ export type DenoRuntimeOptions<TDefinition extends ApplicationDefinition> = {
     readonly application: HttpApplication<TDefinition>;
     readonly environment?: unknown;
 } & BootstrapArguments<TDefinition>;
-export type DenoServeOptions<TDefinition extends ApplicationDefinition> = DenoRuntimeOptions<TDefinition> & {
+export type DenoCreateOptions<TDefinition extends ApplicationDefinition> = DenoRuntimeOptions<TDefinition>;
+export interface DenoServeOptions {
     readonly port?: number;
     readonly hostname?: string;
     readonly shutdownHooks?: boolean;
-};
+}
 export interface DenoBinding {
     fetch(request: Request): Promise<Response>;
     close(signal?: string): Promise<void>;
 }
-export interface DenoServeHandle<TDefinition extends ApplicationDefinition = ApplicationDefinition> {
-    readonly application: HostBindingApplication<TDefinition>;
+export interface DenoListenerHandle {
     readonly port: number;
-    close(signal?: string): Promise<void>;
 }
+export type DenoRuntimeApplication<TDefinition extends ApplicationDefinition = ApplicationDefinition> = HostBindingApplication<TDefinition> & {
+    serve(options?: DenoServeOptions): Promise<DenoListenerHandle>;
+};
 export declare const denoRuntime: {
     readonly runtime: 'deno';
     readonly capabilities: Set<string>;
     readonly bind: typeof bind;
-    readonly serve: typeof serve;
+    readonly create: typeof create;
 };
 declare function bind<const TDefinition extends ApplicationDefinition>(options: DenoRuntimeOptions<TDefinition>): DenoBinding;
-declare function serve<const TDefinition extends ApplicationDefinition>(options: DenoServeOptions<TDefinition>): Promise<DenoServeHandle<TDefinition>>;
+declare function create<const TDefinition extends ApplicationDefinition>(options: DenoCreateOptions<TDefinition>): Promise<DenoRuntimeApplication<TDefinition>>;
 export {};

package/dist/adapters/deno.js

@@ -16,7 +16,7 @@ export const denoRuntime = {
         'crypto.random',
     ]),
     bind,
-    serve,
+    create,
 };
 function bind(options) {
     assertRuntimeEngine('deno');
@@ -34,18 +34,15 @@ function bind(options) {
         close: (signal) => invocation.application.close(signal),
     };
 }
-async function serve(options) {
+async function create(options) {
     assertRuntimeEngine('deno');
     const deno = denoGlobal();
-    if (!deno?.serve) {
-        throw new Error('LUTRE_DENO_UNAVAILABLE: Deno.serve() is not available.');
-    }
     const startedAt = performance.now();
-    const isTTY = deno.stdout?.isTerminal?.() === true;
+    const isTTY = deno?.stdout?.isTerminal?.() === true;
     const presentation = startStartupPresentation({ version: LOUTRE_VERSION }, {
         terminal: {
             isTTY,
-            color: isTTY && deno.env?.get?.('NO_COLOR') === undefined,
+            color: isTTY && deno?.env?.get?.('NO_COLOR') === undefined,
         },
         write: (value) => console.log(value),
     });
@@ -53,55 +50,32 @@ async function serve(options) {
     const http = 'http' in host ? host.http : undefined;
     if (!http) {
         await host.application.close();
-        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: denoRuntime.serve() requires an HTTP-capable Application.');
+        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: denoRuntime.create() requires an HTTP-capable Application.');
     }
     await host.application.init();
-    if ('triggers' in host.application)
-        await host.application.triggers.start();
+    const application = host.application;
+    const closeApplication = host.application.close.bind(host.application);
     let server;
-    const requestedPort = options.port;
-    let port = requestedPort ?? 3000;
-    while (true) {
-        try {
-            server = deno.serve({
-                port,
-                ...(options.hostname === undefined
-                    ? {}
-                    : { hostname: options.hostname }),
-                onListen: () => undefined,
-            }, createDenoFetchDriver(http));
-            break;
-        }
-        catch (error) {
-            if (requestedPort !== undefined || !canRetryOnNextPort(error, port)) {
-                await host.application.close().catch(() => undefined);
-                throw error;
-            }
-            port += 1;
-        }
-    }
-    presentation.ready({
-        server: serverUrl(options.hostname, port),
-        runtime: `Deno ${deno.version?.deno ?? 'unknown'}`,
-        environment: deno.env?.get?.('DENO_ENV') ??
-            deno.env?.get?.('NODE_ENV') ??
-            'development',
-        startupDurationMs: performance.now() - startedAt,
-    });
+    let removeShutdownHooks;
+    let serving = false;
     let closed = false;
-    const closeRuntime = async (signal) => {
+    const close = async (signal) => {
         if (closed)
             return;
         closed = true;
+        removeShutdownHooks?.();
+        removeShutdownHooks = undefined;
         const errors = [];
-        try {
-            await server.shutdown();
-        }
-        catch (error) {
-            errors.push(error);
+        if (server) {
+            try {
+                await server.shutdown();
+            }
+            catch (error) {
+                errors.push(error);
+            }
         }
         try {
-            await host.application.close(signal);
+            await closeApplication(signal);
         }
         catch (error) {
             errors.push(error);
@@ -109,14 +83,62 @@ async function serve(options) {
         if (errors.length > 0)
             throw new AggregateError(errors, 'Deno runtime shutdown failed');
     };
-    const removeShutdownHooks = options.shutdownHooks === false
-        ? undefined
-        : registerDenoShutdownHooks(deno, closeRuntime);
-    const close = async (signal) => {
-        removeShutdownHooks?.();
-        await closeRuntime(signal);
+    const serve = async (serveOptions = {}) => {
+        if (closed) {
+            throw new Error('LUTRE_APP_STOPPED: Application is stopped.');
+        }
+        if (serving) {
+            throw new Error('LUTRE_RUNTIME_ALREADY_SERVING: Deno runtime Application is already serving.');
+        }
+        if (!deno?.serve) {
+            await close().catch(() => undefined);
+            throw new Error('LUTRE_DENO_UNAVAILABLE: Deno.serve() is not available.');
+        }
+        serving = true;
+        try {
+            if ('triggers' in application)
+                await application.triggers.start();
+            const requestedPort = serveOptions.port;
+            let port = requestedPort ?? 3000;
+            while (true) {
+                try {
+                    server = deno.serve({
+                        port,
+                        ...(serveOptions.hostname === undefined
+                            ? {}
+                            : { hostname: serveOptions.hostname }),
+                        onListen: () => undefined,
+                    }, createDenoFetchDriver(http));
+                    break;
+                }
+                catch (error) {
+                    if (requestedPort !== undefined || !canRetryOnNextPort(error, port)) {
+                        throw error;
+                    }
+                    port += 1;
+                }
+            }
+            presentation.ready({
+                server: serverUrl(serveOptions.hostname, port),
+                runtime: `Deno ${deno.version?.deno ?? 'unknown'}`,
+                environment: deno.env?.get?.('DENO_ENV') ??
+                    deno.env?.get?.('NODE_ENV') ??
+                    'development',
+                startupDurationMs: performance.now() - startedAt,
+            });
+            removeShutdownHooks =
+                serveOptions.shutdownHooks === false
+                    ? undefined
+                    : registerDenoShutdownHooks(deno, close);
+            return { port };
+        }
+        catch (error) {
+            await close().catch(() => undefined);
+            throw error;
+        }
     };
-    return { application: host.application, port, close };
+    Object.assign(application, { serve, close });
+    return application;
 }
 function registerDenoShutdownHooks(deno, close) {
     if (!deno.addSignalListener || !deno.removeSignalListener) {

package/dist/application/binding.js

@@ -109,6 +109,9 @@ function createRuntimeState(options) {
 function createInvocationApplication(state) {
     const application = {
         graph: state.graph,
+        get(token) {
+            return state.runtime.get(token);
+        },
         async init() {
             await state.runtime.initialize();
             return application;

package/dist/application/index.d.ts

@@ -1,4 +1,4 @@
-import type { ArgsClass, ModuleProtocols, ModuleInstance, SchemaInput, TaskArguments, TaskDescriptor, TaskOutput, TriggerDescriptor } from '../core/index.js';
+import type { ArgsClass, ModuleProtocols, ModuleInstance, SchemaInput, TaskArguments, TaskDescriptor, TaskOutput, TokenLike, TokenValue, TriggerDescriptor } from '../core/index.js';
 import type { ApplicationGraphIR } from '../graph/index.js';
 import type { Logger } from '../runtime/index.js';
 export interface ApplicationDefinitionOptions<TModules extends readonly ModuleInstance[], TArguments extends ArgsClass | undefined, TTasks extends readonly TaskDescriptor<any, any>[], TTriggers extends readonly TriggerDescriptor[]> {
@@ -27,6 +27,7 @@ export type BootstrapArguments<TDefinition extends ApplicationDefinition> = TDef
 };
 export interface BaseApplication {
     readonly graph: ApplicationGraphIR;
+    get<TToken extends TokenLike>(token: TToken): TokenValue<TToken>;
     init(): Promise<this>;
     close(signal?: string): Promise<void>;
 }

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const LOUTRE_VERSION = "0.3.0";
+export declare const LOUTRE_VERSION = "0.4.1";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // package manifestとのずれを避けるため、scripts/generate-version.mjsがbuild前に更新する。
-export const LOUTRE_VERSION = '0.3.0';
+export const LOUTRE_VERSION = '0.4.1';

package/dist/runtime/application.d.ts

@@ -1,4 +1,4 @@
-import { type ArgsClass, type EnvClass, type ModuleInstance, type ModuleTemplate, type TaskArguments, type TaskDescriptor, type TaskOutput } from '../core/index.js';
+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 {
@@ -27,6 +27,7 @@ export declare class ApplicationRuntime {
     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>>;

package/dist/runtime/application.js

@@ -164,6 +164,18 @@ export class ApplicationRuntime {
         }
         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.`));
@@ -283,9 +295,12 @@ export class ApplicationRuntime {
     }
 }
 function applicationStateError(code) {
-    return new Error(code === 'LUTRE_APP_STOPPING'
-        ? `${code}: Application is stopping and cannot accept new executions.`
-        : `${code}: Application is stopped and cannot accept new executions.`);
+    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 = [];

package/dist/runtime/di.d.ts

@@ -24,6 +24,7 @@ export declare class Container {
     bindEnvironment(environment: EnvClass, value: object): void;
     bindArguments(argumentsContract: ArgsClass, value: object): void;
     resolve<T>(token: TokenLike<T>): T;
+    get<T>(token: TokenLike<T>): T;
     probeClass<T>(target: Class<T>): T;
     prepareImplementation(implementation: ImplementationDescriptor): void;
     implementationRuntime(implementation: ImplementationDescriptor): object;

package/dist/runtime/di.js

@@ -110,6 +110,37 @@ export class Container {
     resolve(token) {
         return this.#resolve(token);
     }
+    get(token) {
+        const provider = this.#providers.get(token);
+        if (!provider) {
+            if (isEnvClass(token)) {
+                throw new DependencyResolutionError(`LUTRE_ENV_002: ${token.name} is not declared by any Module.environment.`);
+            }
+            if (isArgsClass(token)) {
+                throw new DependencyResolutionError(`LUTRE_ARGS_002: ${token.name} is not declared by Application.arguments.`);
+            }
+            throw new DependencyResolutionError(`LUTRE_DI_UNRESOLVED: Application requires ${tokenName(token)}, but no provider is declared for ${tokenName(token)}.`);
+        }
+        if (provider.scope !== 'application') {
+            throw new DependencyResolutionError(`LUTRE_DI_SCOPED_GET: ${tokenName(token)} is ${provider.scope}-scoped and cannot be retrieved with Application.get().`);
+        }
+        if (provider.kind === 'environment') {
+            if (this.#environment.has(provider.provide)) {
+                return this.#environment.get(provider.provide);
+            }
+            throw new DependencyResolutionError(`LUTRE_ENV_005: Environment ${provider.provide.name} requires a runtime Environment source before Application initialization.`);
+        }
+        if (provider.kind === 'arguments') {
+            if (this.#arguments.has(provider.provide)) {
+                return this.#arguments.get(provider.provide);
+            }
+            throw new DependencyResolutionError(`LUTRE_ARGS_005: Arguments ${provider.provide.name} requires runtime Arguments before Application initialization.`);
+        }
+        if (this.#applicationCache.has(token)) {
+            return this.#applicationCache.get(token);
+        }
+        throw new DependencyResolutionError(`LUTRE_DI_NOT_INITIALIZED: ${tokenName(token)} has not been constructed by Application initialization.`);
+    }
     probeClass(target) {
         try {
             return this.#instantiate(target, [target]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loutrejs/loutre",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "license": "MIT",
   "type": "module",
   "files": [