@loutrejs/loutre 0.1.0

package/dist/runtime/logger.js

@@ -0,0 +1,207 @@
+export class ConsoleLoggerBackend {
+    #colors;
+    #prefix;
+    constructor(options = {}) {
+        this.#colors = options.colors ?? detectConsoleColors();
+        this.#prefix = options.prefix ?? 'Loutre';
+    }
+    write(record) {
+        writeToConsole(record.level, formatConsoleLogRecord(record, this.#prefix, this.#colors));
+    }
+}
+export class JsonConsoleLoggerBackend {
+    write(record) {
+        writeToConsole(record.level, serializeLogRecord(record));
+    }
+}
+class SilentLoggerBackend {
+    write(_record) { }
+}
+export class Logger {
+    backend;
+    context;
+    constructor(backend = new ConsoleLoggerBackend(), context = {}) {
+        this.backend = backend;
+        this.context = context;
+    }
+    child(context) {
+        return new Logger(this.backend, { ...this.context, ...context });
+    }
+    debug(message, context = {}) {
+        this.#write('debug', message, context);
+    }
+    info(message, context = {}) {
+        this.#write('info', message, context);
+    }
+    warn(message, context = {}) {
+        this.#write('warn', message, context);
+    }
+    error(message, context = {}) {
+        this.#write('error', message, context);
+    }
+    #write(level, message, context) {
+        this.backend.write({
+            ...this.context,
+            ...context,
+            timestamp: new Date().toISOString(),
+            level,
+            message,
+        });
+    }
+}
+export class SilentLogger extends Logger {
+    constructor(context = {}) {
+        super(new SilentLoggerBackend(), context);
+    }
+}
+function serializeLogRecord(record) {
+    const seen = new WeakSet();
+    try {
+        return JSON.stringify(record, (_key, value) => {
+            if (typeof value === 'bigint')
+                return value.toString();
+            if (value instanceof Error) {
+                return {
+                    name: value.name,
+                    message: value.message,
+                    ...(value.stack === undefined ? {} : { stack: value.stack }),
+                    ...(value.cause === undefined ? {} : { cause: value.cause }),
+                };
+            }
+            if (value !== null && typeof value === 'object') {
+                if (seen.has(value))
+                    return '[Circular]';
+                seen.add(value);
+            }
+            return value;
+        });
+    }
+    catch (error) {
+        return JSON.stringify({
+            timestamp: record.timestamp,
+            level: 'error',
+            message: 'Log record serialization failed',
+            serializationError: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+function writeToConsole(level, value) {
+    const target = level === 'error'
+        ? console.error
+        : level === 'warn'
+            ? console.warn
+            : console.log;
+    target(value);
+}
+function formatConsoleLogRecord(record, prefix, colors) {
+    const { timestamp, level, message, ...recordContext } = record;
+    const context = { ...recordContext };
+    const source = typeof context.source === 'string'
+        ? context.source
+        : typeof context.protocol === 'string'
+            ? context.protocol
+            : undefined;
+    if (source !== undefined)
+        delete context.source;
+    const runtimeProcess = getRuntimeProcess();
+    const processLabel = runtimeProcess?.pid === undefined
+        ? `[${prefix}]`
+        : `[${prefix}] ${runtimeProcess.pid}`;
+    const levelLabel = level === 'info' ? 'LOG' : level.toUpperCase();
+    const levelColor = level === 'error' ? 31 : level === 'warn' ? 33 : level === 'debug' ? 36 : 32;
+    const sourceLabel = source === undefined ? '' : `${paint(`[${source}]`, 33, colors)} `;
+    const formattedContext = formatLogContext(context);
+    const contextSuffix = formattedContext === '' ? '' : ` ${paint(formattedContext, 90, colors)}`;
+    return `${paint(processLabel, 32, colors)}  - ${formatLocalTimestamp(timestamp)}  ${paint(levelLabel.padStart(7), levelColor, colors)} ${sourceLabel}${paint(message, levelColor, colors)}${contextSuffix}`;
+}
+function formatLogContext(context) {
+    const entries = Object.entries(context);
+    if (entries.length === 0)
+        return '';
+    return `{ ${entries
+        .map(([key, value]) => `${formatLogKey(key)}=${formatLogValue(value)}`)
+        .join(', ')} }`;
+}
+function formatLogKey(key) {
+    return /^[A-Za-z_$][\w$]*$/u.test(key) ? key : JSON.stringify(key);
+}
+function formatLogValue(value, ancestors = new WeakSet()) {
+    try {
+        if (value === null)
+            return 'null';
+        if (value === undefined)
+            return 'undefined';
+        if (typeof value === 'string') {
+            return /^[\w./:@+-]+$/u.test(value) ? value : JSON.stringify(value);
+        }
+        if (typeof value === 'number' || typeof value === 'boolean')
+            return String(value);
+        if (typeof value === 'bigint')
+            return `${value}n`;
+        if (typeof value === 'symbol')
+            return String(value);
+        if (typeof value === 'function')
+            return `[Function ${value.name || 'anonymous'}]`;
+        if (ancestors.has(value))
+            return '[Circular]';
+        ancestors.add(value);
+        try {
+            if (value instanceof Date)
+                return value.toISOString();
+            if (value instanceof Error) {
+                return formatLogValue({
+                    name: value.name,
+                    message: value.message,
+                    ...(value.stack === undefined ? {} : { stack: value.stack }),
+                    ...(value.cause === undefined ? {} : { cause: value.cause }),
+                }, ancestors);
+            }
+            if (Array.isArray(value)) {
+                return `[${value.map((item) => formatLogValue(item, ancestors)).join(', ')}]`;
+            }
+            return `{ ${Object.entries(value)
+                .map(([key, item]) => `${formatLogKey(key)}=${formatLogValue(item, ancestors)}`)
+                .join(', ')} }`;
+        }
+        finally {
+            ancestors.delete(value);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `[Unformattable: ${message}]`;
+    }
+}
+function formatLocalTimestamp(timestamp) {
+    const date = new Date(timestamp);
+    if (Number.isNaN(date.getTime()))
+        return timestamp;
+    return ([
+        date.getFullYear(),
+        String(date.getMonth() + 1).padStart(2, '0'),
+        String(date.getDate()).padStart(2, '0'),
+    ].join('/') +
+        ` ${[
+            String(date.getHours()).padStart(2, '0'),
+            String(date.getMinutes()).padStart(2, '0'),
+            String(date.getSeconds()).padStart(2, '0'),
+        ].join(':')}.${String(date.getMilliseconds()).padStart(3, '0')}`);
+}
+function paint(value, color, enabled) {
+    return enabled ? `\u001B[${color}m${value}\u001B[39m` : value;
+}
+function getRuntimeProcess() {
+    return globalThis.process;
+}
+function detectConsoleColors() {
+    const runtimeProcess = getRuntimeProcess();
+    const environment = runtimeProcess?.env;
+    if (environment?.NO_COLOR !== undefined ||
+        environment?.NODE_DISABLE_COLORS !== undefined) {
+        return false;
+    }
+    if (environment?.FORCE_COLOR !== undefined) {
+        return environment.FORCE_COLOR !== '0';
+    }
+    return runtimeProcess?.stdout?.isTTY === true;
+}

package/dist/runtime/node-capabilities.d.ts

@@ -0,0 +1,5 @@
+/** CLIが`@loutrejs/node`へ依存するとBun/DenoでもNode.js専用moduleを評価するため、Capability metadataだけをruntime-neutral側へ分離する。 */
+export declare const nodeRuntimeCapabilities: {
+    readonly runtime: 'node';
+    readonly capabilities: Set<string>;
+};

package/dist/runtime/node-capabilities.js

@@ -0,0 +1,18 @@
+/** CLIが`@loutrejs/node`へ依存するとBun/DenoでもNode.js専用moduleを評価するため、Capability metadataだけをruntime-neutral側へ分離する。 */
+export const nodeRuntimeCapabilities = {
+    runtime: 'node',
+    capabilities: new Set([
+        'http.server',
+        'http.request.streaming',
+        'http.response.streaming',
+        'stream.readable',
+        'stream.writable',
+        'messagePort.send',
+        'messagePort.receive',
+        'messagePort.transfer',
+        'runtime.longLived',
+        'runtime.shutdownHook',
+        'env.runtime',
+        'crypto.random',
+    ]),
+};

package/dist/runtime/pipeline.d.ts

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

@@ -0,0 +1,161 @@
+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が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}のnext()は1回だけ実行できます`);
+            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}はnext()後にshortCircuitできません`);
+        }
+        return {
+            kind: 'complete',
+            result: runtimeResult.result,
+        };
+    }
+    if (calls === 0) {
+        throw new LayerContractError(`LUTRE_LAYER_NEXT_SKIPPED: Layer ${layer.name}はnext()を1回実行する必要があります`);
+    }
+    return continuationFlow;
+}
+function assertRequiredContext(layerName, requiredKeys, availableKeys) {
+    for (const required of requiredKeys) {
+        if (!availableKeys.has(required)) {
+            throw new LayerContractError(`${layerName}が必要とするContext Key ${contextKeyName(required)}は利用できません`);
+        }
+    }
+}
+function applyProvidedContext(layer, context, availableKeys, arguments_) {
+    if (arguments_.length > 1) {
+        throw new LayerContractError(`${layer.name}のnext()へ渡せるContext objectは1つだけです`);
+    }
+    if (layer.provides.length === 0) {
+        if (arguments_.length > 0) {
+            const provided = arguments_[0];
+            const property = firstProperty(provided);
+            throw new LayerContractError(property === undefined
+                ? `${layer.name}はContextをprovideすると宣言していません`
+                : `${layer.name}が未宣言のContext property ${property}をprovideしました`);
+        }
+        return;
+    }
+    const provided = arguments_[0];
+    if (typeof provided !== 'object' ||
+        provided === null ||
+        Array.isArray(provided)) {
+        throw new LayerContractError(`${layer.name}はprovidesで宣言したContextを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.name}が未宣言のContext property ${property}をprovideしました`);
+        }
+    }
+    const providedNames = new Set();
+    for (const key of layer.provides) {
+        if (providedNames.has(key.name)) {
+            throw new LayerContractError(`${layer.name}がContext property ${key.name}を重複して宣言しました`);
+        }
+        providedNames.add(key.name);
+        if (!Object.hasOwn(additions, key.name)) {
+            throw new LayerContractError(`${layer.name}が宣言したContext Key ${contextKeyName(key)}をprovideしませんでした`);
+        }
+        if (Object.hasOwn(context, key.name)) {
+            throw new LayerContractError(`${layer.name}は既存の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];
+}

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@loutrejs/loutre",
+  "version": "0.1.0",
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "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"
+    },
+    "./graph": {
+      "types": "./dist/graph/index.d.ts",
+      "import": "./dist/graph/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "import": "./dist/runtime/index.js"
+    },
+    "./http": {
+      "types": "./dist/http/index.d.ts",
+      "import": "./dist/http/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"
+    },
+    "./runtime/bun": {
+      "types": "./dist/adapters/bun.d.ts",
+      "import": "./dist/adapters/bun.js"
+    },
+    "./runtime/deno": {
+      "types": "./dist/adapters/deno.d.ts",
+      "import": "./dist/adapters/deno.js"
+    },
+    "./runtime/cloudflare-workers": {
+      "types": "./dist/adapters/cloudflare-workers.d.ts",
+      "import": "./dist/adapters/cloudflare-workers.js"
+    },
+    "./runtime/aws-lambda": {
+      "types": "./dist/adapters/aws-lambda.d.ts",
+      "import": "./dist/adapters/aws-lambda.js"
+    },
+    "./runtime/electron": {
+      "types": "./dist/adapters/electron.d.ts",
+      "import": "./dist/adapters/electron.js"
+    }
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@standard-schema/spec": "^1.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/come25136/loutrejs",
+    "directory": "packages/loutre"
+  }
+}