@hypequery/deployment 0.0.0-canary-20260719200737 → 0.1.0

package/dist/runtime-supervisor.js

@@ -1,254 +0,0 @@
-const DEFAULT_DRAIN_TIMEOUT_MS = 30_000;
-const DEFAULT_RECONCILE_ATTEMPTS = 4;
-const MAX_DRAIN_TIMEOUT_MS = 5 * 60_000;
-const MAX_RECONCILE_ATTEMPTS = 16;
-export class DeploymentRuntimeSupervisorError extends Error {
-    code;
-    constructor(code, message, options = {}) {
-        super(message, options.cause === undefined ? undefined : { cause: options.cause });
-        this.name = 'DeploymentRuntimeSupervisorError';
-        this.code = code;
-    }
-}
-function supervisorError(code, message, cause) {
-    return new DeploymentRuntimeSupervisorError(code, message, { cause });
-}
-function boundedInteger(input, fallback, maximum, name, allowZero = false) {
-    const value = input ?? fallback;
-    if (!Number.isSafeInteger(value) || value < (allowZero ? 0 : 1) || value > maximum) {
-        throw supervisorError('HQ_RUNTIME_SUPERVISOR_CONFIGURATION', `${name} must be an integer between ${allowZero ? 0 : 1} and ${maximum}.`);
-    }
-    return value;
-}
-function targetKey(target) {
-    return JSON.stringify([target.project, target.environment]);
-}
-function sameTarget(left, right) {
-    return left.project === right.project && left.environment === right.environment;
-}
-function status(generation) {
-    const snapshot = generation.snapshot;
-    return Object.freeze({
-        target: snapshot.target,
-        activationRevision: snapshot.activation.revision,
-        releaseIdentity: snapshot.releaseIdentity,
-        bundleIdentity: snapshot.bundleIdentity,
-    });
-}
-function throwIfAborted(signal) {
-    if (signal?.aborted) {
-        throw supervisorError('HQ_RUNTIME_ABORTED', 'The runtime operation was aborted.', signal.reason);
-    }
-}
-function binding(snapshot, queryName) {
-    const query = snapshot.deployment.queries.find(candidate => candidate.name === queryName);
-    if (!query) {
-        throw supervisorError('HQ_RUNTIME_QUERY_NOT_FOUND', `Runtime query not found: ${queryName}`);
-    }
-    if (query.implementation.kind !== 'runtime-reference') {
-        throw supervisorError('HQ_RUNTIME_QUERY_NOT_EXECUTABLE', `Query is portable and does not use a supervised runtime: ${queryName}`);
-    }
-    const resolved = snapshot.queries.find(candidate => candidate.query === queryName);
-    if (!resolved) {
-        throw supervisorError('HQ_RUNTIME_QUERY_NOT_EXECUTABLE', `Runtime query binding is unavailable: ${queryName}`);
-    }
-    return resolved;
-}
-export function createDeploymentRuntimeSupervisor(options) {
-    const drainTimeoutMs = boundedInteger(options.drainTimeoutMs, DEFAULT_DRAIN_TIMEOUT_MS, MAX_DRAIN_TIMEOUT_MS, 'drainTimeoutMs', true);
-    const maxReconcileAttempts = boundedInteger(options.maxReconcileAttempts, DEFAULT_RECONCILE_ATTEMPTS, MAX_RECONCILE_ATTEMPTS, 'maxReconcileAttempts');
-    const active = new Map();
-    const updates = new Map();
-    const background = new Set();
-    const backgroundFailures = [];
-    let closed = false;
-    let closePromise;
-    function ensureOpen() {
-        if (closed)
-            throw supervisorError('HQ_RUNTIME_SUPERVISOR_CLOSED', 'Runtime supervisor is closed.');
-    }
-    async function drain(generation) {
-        if (generation.draining)
-            return;
-        generation.draining = true;
-        if (generation.inFlight > 0) {
-            await new Promise(resolve => {
-                let settled = false;
-                const finish = () => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    clearTimeout(timer);
-                    generation.drained = undefined;
-                    resolve();
-                };
-                generation.drained = finish;
-                const timer = setTimeout(finish, drainTimeoutMs);
-                timer.unref();
-            });
-        }
-        await generation.instance.close();
-    }
-    function drainInBackground(generation) {
-        const operation = drain(generation).catch(error => {
-            backgroundFailures.push(error);
-            options.onBackgroundError?.(error);
-        });
-        background.add(operation);
-        void operation.finally(() => background.delete(operation));
-    }
-    async function safeClose(instance) {
-        try {
-            await instance.close();
-        }
-        catch (error) {
-            backgroundFailures.push(error);
-            options.onBackgroundError?.(error);
-        }
-    }
-    async function performReconcile(target, signal) {
-        for (let attempt = 0; attempt < maxReconcileAttempts; attempt += 1) {
-            ensureOpen();
-            throwIfAborted(signal);
-            const snapshot = await options.materializer.current(target);
-            ensureOpen();
-            throwIfAborted(signal);
-            const key = targetKey(target);
-            const existing = active.get(key);
-            if (!snapshot) {
-                if (!existing)
-                    return Object.freeze({ status: 'no-active-release' });
-                active.delete(key);
-                drainInBackground(existing);
-                return Object.freeze({ status: 'deactivated', previous: status(existing) });
-            }
-            if (!sameTarget(snapshot.target, target)) {
-                throw supervisorError('HQ_RUNTIME_START_FAILED', 'The materialized runtime snapshot does not match the requested target.');
-            }
-            if (existing?.snapshot.activation.revision === snapshot.activation.revision) {
-                return Object.freeze({ status: 'already-current', runtime: status(existing) });
-            }
-            let candidate;
-            try {
-                candidate = await options.factory.start(snapshot, { signal });
-            }
-            catch (error) {
-                if (signal?.aborted) {
-                    throw supervisorError('HQ_RUNTIME_ABORTED', 'The runtime operation was aborted while starting a candidate.', error);
-                }
-                if (error instanceof DeploymentRuntimeSupervisorError)
-                    throw error;
-                throw supervisorError('HQ_RUNTIME_START_FAILED', 'The candidate deployment runtime could not be started.', error);
-            }
-            try {
-                ensureOpen();
-                throwIfAborted(signal);
-                await candidate.healthCheck({ signal });
-            }
-            catch (error) {
-                await safeClose(candidate);
-                if (error instanceof DeploymentRuntimeSupervisorError)
-                    throw error;
-                throw supervisorError('HQ_RUNTIME_HEALTH_FAILED', 'The candidate deployment runtime did not become ready.', error);
-            }
-            let confirmed;
-            try {
-                ensureOpen();
-                throwIfAborted(signal);
-                confirmed = await options.materializer.current(target);
-                ensureOpen();
-                throwIfAborted(signal);
-            }
-            catch (error) {
-                await safeClose(candidate);
-                throw error;
-            }
-            if (confirmed?.activation.revision !== snapshot.activation.revision) {
-                await safeClose(candidate);
-                continue;
-            }
-            const generation = {
-                snapshot,
-                instance: candidate,
-                inFlight: 0,
-                draining: false,
-            };
-            const previous = active.get(key);
-            active.set(key, generation);
-            if (previous)
-                drainInBackground(previous);
-            return Object.freeze({ status: 'activated', runtime: status(generation) });
-        }
-        throw supervisorError('HQ_RUNTIME_RECONCILE_UNSTABLE', 'Deployment activation changed repeatedly while starting a runtime.');
-    }
-    function serialize(key, operation) {
-        const previous = updates.get(key) ?? Promise.resolve();
-        const current = previous.catch(() => undefined).then(operation);
-        const tracked = current.finally(() => {
-            if (updates.get(key) === tracked)
-                updates.delete(key);
-        });
-        updates.set(key, tracked);
-        return tracked;
-    }
-    return Object.freeze({
-        async reconcile(target, reconcileOptions = {}) {
-            ensureOpen();
-            return await serialize(targetKey(target), () => performReconcile(target, reconcileOptions.signal));
-        },
-        async invoke(input) {
-            ensureOpen();
-            throwIfAborted(input.signal);
-            const generation = active.get(targetKey(input.target));
-            if (!generation) {
-                throw supervisorError('HQ_RUNTIME_NOT_READY', 'No deployment runtime is ready for target.');
-            }
-            const resolved = binding(generation.snapshot, input.query);
-            generation.inFlight += 1;
-            try {
-                return await generation.instance.invoke({
-                    query: input.query,
-                    binding: resolved,
-                    argument: input.argument,
-                    signal: input.signal,
-                });
-            }
-            catch (error) {
-                if (error instanceof DeploymentRuntimeSupervisorError)
-                    throw error;
-                throw supervisorError('HQ_RUNTIME_INVOCATION_FAILED', 'The deployment runtime invocation failed.', error);
-            }
-            finally {
-                generation.inFlight -= 1;
-                if (generation.draining && generation.inFlight === 0)
-                    generation.drained?.();
-            }
-        },
-        status(target) {
-            const generation = active.get(targetKey(target));
-            return generation ? status(generation) : undefined;
-        },
-        close() {
-            if (closePromise)
-                return closePromise;
-            closed = true;
-            closePromise = (async () => {
-                await Promise.allSettled([...updates.values()]);
-                const generations = [...active.values()];
-                active.clear();
-                const results = await Promise.allSettled(generations.map(generation => drain(generation)));
-                await Promise.allSettled([...background]);
-                const failures = [
-                    ...backgroundFailures,
-                    ...results
-                        .filter((result) => result.status === 'rejected')
-                        .map(result => result.reason),
-                ];
-                if (failures.length > 0) {
-                    throw new AggregateError(failures, 'One or more deployment runtimes could not be closed.');
-                }
-            })();
-            return closePromise;
-        },
-    });
-}