@loutrejs/loutre 0.7.0 → 0.8.1

package/dist/adapters/deno.js

@@ -1,231 +0,0 @@
-import { createKernelApplication, } from '../application/index.js';
-import { bindApplicationCapability } from '../application/kernel-internal.js';
-import { httpExecutionExtension } from '../http/index.js';
-import { LOUTRE_VERSION, startStartupPresentation } from '../presentation.js';
-import { assertRuntimeEngine } from '../runtime/engine.js';
-import { serverUrl } from '../runtime/server-url.js';
-import { canRetryOnNextPort, initialServerPort, } from '../runtime/server-port.js';
-export const denoRuntime = {
-    runtime: 'deno',
-    capabilities: new Set([
-        'http.server',
-        'http.request.streaming',
-        'http.response.streaming',
-        'stream.readable',
-        'stream.writable',
-        'runtime.longLived',
-        'runtime.shutdownHook',
-        'env.runtime',
-        'crypto.random',
-    ]),
-    bind,
-    create,
-};
-function bind(options) {
-    assertRuntimeEngine('deno');
-    if (options.application.model.extensions.get(httpExecutionExtension) ===
-        undefined) {
-        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: denoRuntime.bind() requires the HTTP Execution Extension.');
-    }
-    const application = createKernelApplication({
-        ...options,
-        application: options.application,
-        capabilities: [
-            bindApplicationCapability(options.application.model, 'http.server', {
-                runtime: 'deno',
-            }),
-            ...(options.capabilities ?? []),
-        ],
-        environment: 'environment' in options ? options.environment : denoEnvironment(),
-    });
-    let initialization;
-    return {
-        async fetch(request) {
-            initialization ??= application.init();
-            await initialization;
-            return application.http.fetch(request);
-        },
-        close: (signal) => application.close(signal),
-    };
-}
-async function create(options) {
-    assertRuntimeEngine('deno');
-    const deno = denoGlobal();
-    const startedAt = performance.now();
-    const isTTY = deno?.stdout?.isTerminal?.() === true;
-    const presentation = startStartupPresentation({ version: LOUTRE_VERSION }, {
-        terminal: {
-            isTTY,
-            color: isTTY && deno?.env?.get?.('NO_COLOR') === undefined,
-        },
-        write: (value) => console.log(value),
-    });
-    if (options.application.model.extensions.get(httpExecutionExtension) ===
-        undefined) {
-        throw new Error('LUTRE_RUNTIME_HTTP_REQUIRED: denoRuntime.create() requires the HTTP Execution Extension.');
-    }
-    const hosted = createKernelApplication({
-        ...options,
-        application: options.application,
-        capabilities: [
-            bindApplicationCapability(options.application.model, 'http.server', {
-                runtime: 'deno',
-            }),
-            ...(options.capabilities ?? []),
-        ],
-        environment: 'environment' in options ? options.environment : denoEnvironment(),
-    });
-    await hosted.init();
-    const application = hosted;
-    const http = hosted
-        .http;
-    const closeApplication = application.close.bind(application);
-    let server;
-    let removeShutdownHooks;
-    let serving = false;
-    let closed = false;
-    let closingPromise;
-    let serverClosingPromise;
-    const beginServerClose = () => {
-        if (serverClosingPromise)
-            return serverClosingPromise;
-        if (!server)
-            return Promise.resolve();
-        const closingServer = server;
-        serverClosingPromise = Promise.resolve()
-            .then(() => closingServer.shutdown())
-            .then(() => {
-            if (server === closingServer)
-                server = undefined;
-        }, (error) => {
-            serverClosingPromise = undefined;
-            throw error;
-        });
-        void serverClosingPromise.catch(() => undefined);
-        return serverClosingPromise;
-    };
-    const close = (signal) => {
-        if (closed)
-            return Promise.resolve();
-        if (closingPromise)
-            return closingPromise;
-        closingPromise = (async () => {
-            removeShutdownHooks?.();
-            removeShutdownHooks = undefined;
-            const errors = [];
-            const serverClosing = beginServerClose();
-            try {
-                await closeApplication(signal);
-            }
-            catch (error) {
-                errors.push(error);
-            }
-            if (errors.length === 0) {
-                try {
-                    await serverClosing;
-                }
-                catch (error) {
-                    errors.push(error);
-                }
-            }
-            if (errors.length > 0) {
-                throw new AggregateError(errors, 'Deno runtime shutdown failed');
-            }
-            closed = true;
-        })().catch((error) => {
-            closingPromise = undefined;
-            throw error;
-        });
-        return closingPromise;
-    };
-    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 {
-            const requestedPort = serveOptions.port;
-            let port = initialServerPort(requestedPort);
-            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;
-        }
-    };
-    Object.assign(application, { serve, close });
-    return application;
-}
-function registerDenoShutdownHooks(deno, close) {
-    if (!deno.addSignalListener || !deno.removeSignalListener) {
-        return undefined;
-    }
-    const handlers = new Map();
-    const remove = () => {
-        for (const [signal, handler] of handlers) {
-            deno.removeSignalListener?.(signal, handler);
-        }
-        handlers.clear();
-    };
-    for (const signal of ['SIGINT', 'SIGTERM']) {
-        const handler = () => {
-            remove();
-            void close(signal);
-        };
-        handlers.set(signal, handler);
-        deno.addSignalListener(signal, handler);
-    }
-    return remove;
-}
-function createDenoFetchDriver(application) {
-    let initialization;
-    return async (request) => {
-        initialization ??= application.initialize?.() ?? Promise.resolve();
-        await initialization;
-        return application.fetch(request);
-    };
-}
-function denoEnvironment() {
-    const deno = denoGlobal();
-    return deno?.env?.toObject ? deno.env.toObject() : undefined;
-}
-function denoGlobal() {
-    return globalThis.Deno;
-}