@supalive/core 0.1.4 → 0.1.6

package/dist/src/server/supalive-server.js

@@ -1,1048 +0,0 @@
-import { createServer } from "http";
-import { WebSocketServer, WebSocket } from "ws";
-import { v4 as uuidv4 } from "uuid";
-import Redis from "ioredis";
-import { retry, handleAll, ExponentialBackoff } from "cockatiel";
-import { stableStringify, supaliveStringify } from "../helper";
-import { getContextRegistry, } from "../router";
-import { sleep, SupaliveDb } from "../db/realtime_db";
-import { AuthenticationError, ClientMessageSchema } from "../db/types_client_rpc";
-import { RemoteSubscriptionMessageSchema, } from "./types_server";
-import { PgDatabase } from "../db/postgres";
-import { MySqlDatabase } from "../db/mysql";
-import { ANONYMOUS_IDENTITY, generateSubscriptionId, generateCacheKey, getHashOf, } from "./sub_hash";
-import { CacheLayer } from "../db/cache";
-import { SubManagerClient } from "./subscription-manager-client";
-import { appInstanceId, logger as baseLogger, logLevelOf } from "../logger";
-const redisRetryPolicy = retry(handleAll, {
-    maxAttempts: 3,
-    backoff: new ExponentialBackoff({
-        initialDelay: 100,
-        maxDelay: 5000,
-        exponent: 2,
-    }),
-});
-/**
- * Global broadcast channel used to signal column-type cache invalidation
- * across every running server instance. Publishers (migration tooling,
- * the publishSchemaReload helper below) send a JSON message of shape
- * `{ type: "schema:reload"; tables?: string[]; originInstance?: string }`.
- * Subscribers re-bootstrap from PG (or Redis) so the next batched write
- * sees up-to-date column metadata without a process restart.
- */
-const SCHEMA_RELOAD_CHANNEL = "supalive:schema:reload";
-/**
- * Per-socket cap on pending mutations. The Nth+1 mutation from a single
- * client gets rejected with TOO_MANY_CONCURRENT_MUTATIONS rather than
- * being enqueued — this is rate-limit pressure on a misbehaving client,
- * not a hard system limit.
- *
- * Mirrors Convex's OPERATION_QUEUE_BUFFER_SIZE (1000). Mutations drain
- * one-at-a-time per socket, so a healthy client never approaches this.
- */
-const MAX_MUTATION_QUEUE_BUFFER = 1000;
-/**
- * Per-socket cap on in-flight actions. Actions run in parallel (unlike
- * mutations) because they may do long external work (HTTP, queue calls);
- * the cap exists so one socket can't open thousands of outbound
- * connections from inside the server.
- */
-const MAX_ACTION_CONCURRENCY = 1000;
-/**
- * Default and env override for the per-statement DB timeout. PG enforces
- * this via `statement_timeout` (server cancels), MySQL via the per-query
- * `timeout` option (driver issues KILL QUERY). Set 0 to disable.
- */
-const DB_QUERY_TIMEOUT_MS = Number(process.env.SUPALIVE_DB_QUERY_TIMEOUT_MS ?? 30_000);
-// ─── Heartbeat constants ─────────────────────────────────────
-//
-// Two independent jobs run on a single per-session interval:
-//
-// 1. Dead-TCP detection: terminate sockets that have gone fully silent
-//    (no inbound text/ping/pong) past `CLIENT_TIMEOUT_MS`. Otherwise
-//    emit a ws-protocol ping (browser auto-pongs, refreshing `session.lastReceivedAt`).
-// 2. Client-watchdog refresh: if the application channel has been idle
-//    for at least `HEARTBEAT_INTERVAL_MS`, send a `{type:"ping"}` JSON
-//    frame so the client's inactivity watchdog stays fresh. Busy
-//    sockets skip this (the `lastSentAt` check makes it idle-only).
-//
-// Both fire on the same `heartbeatTimer` — one `setInterval` per session.
-const HEARTBEAT_INTERVAL_MS = Number(process.env.SUPALIVE_HEARTBEAT_INTERVAL_MS ?? 15_000);
-const CLIENT_TIMEOUT_MS = 120_000;
-/**
- * TTL on the Redis lock that elects the recompute winner when the writer
- * doesn't hold the sub locally. Each (subId, commitTs) gets its own lock
- * key, so this only needs to bound the worst-case recompute duration —
- * if the winner crashes mid-recompute, the lock expires and the next
- * mutation triggers a new race.
- */
-const RECOMPUTE_LOCK_TTL_SECONDS = Number(process.env.SUPALIVE_RECOMPUTE_LOCK_TTL_SECONDS ?? 10);
-const logger = baseLogger.child({
-    "name": "SUPALIVE",
-}, { level: logLevelOf("SERVER_LOG_LEVEL") });
-/**
- * Supalive WebSocket Server
- */
-export class SupaliveWebSocketServer {
-    config;
-    instanceId;
-    httpServer;
-    wss;
-    cache;
-    db;
-    contextRegistry;
-    router;
-    sessions = new Map();
-    serverSubscriptions = new Map();
-    subManagerClient;
-    redisSub;
-    stats = {
-        activeConnections: 0,
-        totalConnections: 0,
-        activeSubscriptions: 0,
-    };
-    constructor(config) {
-        this.config = {
-            port: 3000,
-            host: "0.0.0.0",
-            contextName: "default",
-            sessionTtlSeconds: 3600,
-            ...config,
-        };
-        this.instanceId = appInstanceId;
-        if (!config.subManagerUrl) {
-            throw new Error("subManagerUrl config is required (WebSocket URL of the sub-manager process)");
-        }
-        this.subManagerClient = new SubManagerClient(config.subManagerUrl);
-        this.cache = new CacheLayer(new Redis(config.upstash.redisUrl, {
-            connectTimeout: 15_000,
-            maxRetriesPerRequest: 1,
-            keepAlive: 3000,
-        }), this.config.cacheTtlSeconds ?? 3600);
-        this.redisSub = new Redis(config.upstash.redisUrl, {
-            connectTimeout: 15_000,
-            maxRetriesPerRequest: 5,
-            retryStrategy: (times) => {
-                if (times > 5)
-                    return null;
-                return Math.min(times * 200, 2000);
-            }
-        });
-        // Wire the sub-manager client's recovery callbacks to drive re-registration
-        // from this app server's serverSubscriptions whenever the RPC reconnects,
-        // and to process the resulting batched invalidate flush.
-        this.subManagerClient.setRecoveryDriver(this.runSubManagerRecovery.bind(this));
-        this.subManagerClient.setAffectedHandler(this.runAffectedHandler.bind(this));
-        this.httpServer = createServer();
-        this.wss = new WebSocketServer({
-            server: this.httpServer,
-            autoPong: true,
-            maxPayload: 100 * 1024 * 1024,
-            // backlog: //max pending connections queue (default: 511)
-        });
-        this.setupWebSocketHandlers();
-        this.subscribeToInstanceChannel();
-    }
-    /**
-     * Per-session heartbeat. Fires every `HEARTBEAT_INTERVAL_MS` and does
-     * both jobs on the same tick:
-     *
-     *   1. Inactivity check + ws-protocol ping (dead-TCP detection).
-     *   2. App-level `{type:"ping"}` if the channel has been idle for at
-     *      least one heartbeat interval (client-watchdog refresh).
-     *
-     * The `lastSentAt` gate on (2) preserves the original "only ping when
-     * idle" semantics: a session producing sub:updates faster than the
-     * heartbeat interval never emits a redundant app-ping.
-     */
-    startSessionHeartbeat(session) {
-        session.heartbeatTimer = setInterval(() => {
-            // (1) Dead-TCP detection.
-            if (Date.now() - session.lastReceivedAt > CLIENT_TIMEOUT_MS) {
-                logger.info(`ws inactivity → terminate session ${session.id}`);
-                try {
-                    session.ws.terminate();
-                }
-                catch { /* close handler cleans up */ }
-                return;
-            }
-            try {
-                session.ws.ping();
-            }
-            catch {
-                // socket already broken — close handler will clean up
-            }
-            // (2) Client-watchdog refresh, idle-only.
-            if (Date.now() - session.lastSentAt >= HEARTBEAT_INTERVAL_MS) {
-                this.sendMessage(session, { type: "ping" });
-            }
-        }, HEARTBEAT_INTERVAL_MS);
-    }
-    clearSessionTimers(session) {
-        if (session.heartbeatTimer) {
-            clearInterval(session.heartbeatTimer);
-            session.heartbeatTimer = null;
-        }
-    }
-    registerRouter(router) {
-        this.router = router;
-        this.contextRegistry = getContextRegistry(router.contextName);
-    }
-    async initDatabase() {
-        const db = this.createDatabase(this.config.database);
-        this.db = SupaliveDb.create({ db });
-        await this.bootstrapDbTypes();
-    }
-    /**
-     * Eagerly load column types into the apply-path cache at server start.
-     * In production, the result is cached in Redis under
-     * `supalive:schema:types:${SUPALIVE_SCHEMA_VERSION ?? "v1"}` so other
-     * instances starting cold can skip the pg_attribute round-trip. In any
-     * other env we go straight to PG every time so local schema iteration
-     * is never blocked by stale Redis state. Migrations should publish a
-     * `schema:reload` message (see {@link publishSchemaReload}) after
-     * applying DDL — every instance picks that up and re-bootstraps.
-     */
-    async bootstrapDbTypes(forceReload = false) {
-        // TODO: remove this check if we needs mysql column types
-        if (this.db.impl.dbType === "mysql") {
-            // currently we don't use mysql column type
-            return;
-        }
-        const inProd = process.env.NODE_ENV === "production";
-        const version = process.env.SUPALIVE_SCHEMA_VERSION ?? "v1";
-        const key = `supalive:schema:types:${version}`;
-        try {
-            await this.db.impl.bootstrapColumnTypes({
-                cacheKey: key,
-                redis: inProd && !forceReload ? this.cache : undefined,
-            });
-            logger.info({ columnsTypes: this.db.impl.columnTypes }, `Bootstrapped db column types (redis=${inProd}, key=${key})`);
-        }
-        catch (err) {
-            logger.error(err, "Failed to bootstrap db column types");
-            throw err;
-        }
-    }
-    createDatabase(config) {
-        if (config.type === "postgres") {
-            return new PgDatabase(logger.child({ database: "postgres" }), {
-                ...config,
-                connectionString: config.connectionString,
-                min: config.minConnections ?? 0,
-                max: config.maxConnections ?? 20,
-                connectionTimeoutMillis: config.connectionTimeoutMillis ?? 15_000,
-                idleTimeoutMillis: config.idleTimeoutMillis ?? 30_000,
-                // server-enforced per-statement timeout; pg cancels the running
-                // query when it fires. 0 disables it.
-                statement_timeout: DB_QUERY_TIMEOUT_MS > 0 ? DB_QUERY_TIMEOUT_MS : undefined,
-            });
-        }
-        else {
-            return new MySqlDatabase(logger.child({ database: "mysql" }), {
-                ...config,
-                connectionLimit: config.maxConnections ?? 20,
-                connectTimeout: config.connectionTimeoutMillis ?? 15_000,
-                // mysql2 pool: 0 = wait forever for a free conn (default). queueLimit
-                // bounds the wait queue length so backpressure surfaces as an error
-                // rather than unbounded growth.
-                queueLimit: config.queueLimit ?? 0,
-                // driver-side per-statement timeout applied uniformly in
-                // MySqlDatabase.query.
-                queryTimeoutMs: DB_QUERY_TIMEOUT_MS,
-            });
-        }
-    }
-    async start() {
-        await this.initDatabase();
-        return new Promise((resolve) => {
-            this.httpServer.listen(this.config.port, this.config.host, () => {
-                logger.info(`Server: ${this.instanceId} listening on ${this.config.host}:${this.config.port}`);
-                resolve();
-            });
-        });
-    }
-    async stop() {
-        this.wss.close();
-        for (const [ws] of this.sessions) {
-            ws.close(1001, "Server shutting down");
-        }
-        this.httpServer.close();
-        logger.info("Server stopped");
-    }
-    getStats() {
-        return {
-            instanceId: this.instanceId,
-            activeConnections: this.stats.activeConnections,
-            totalConnections: this.stats.totalConnections,
-            activeSubscriptions: this.stats.activeSubscriptions,
-        };
-    }
-    getInstanceId() {
-        return this.instanceId;
-    }
-    setupWebSocketHandlers() {
-        this.wss.on("connection", (ws, req) => {
-            this.handleConnection(ws, req).catch((err) => {
-                logger.error(err, "Connection handler error");
-            });
-        });
-    }
-    async handleConnection(ws, req) {
-        this.stats.totalConnections++;
-        this.stats.activeConnections++;
-        const session = {
-            id: uuidv4(),
-            ws,
-            serverCtx: {},
-            subIds: new Set(),
-            mutationQueue: [],
-            mutationInFlight: false,
-            actionInFlight: 0,
-            lastReceivedAt: Date.now(),
-            lastSentAt: Date.now(),
-            heartbeatTimer: null,
-        };
-        logger.info(`New session: ${session.id}`);
-        this.sessions.set(ws, session);
-        this.sendMessage(session, { type: "connected", sessionId: session.id });
-        // Any inbound frame (text, ws-ping, ws-pong) refreshes the liveness
-        // clock. This is the only thing keeping `CLIENT_TIMEOUT_MS` from
-        // tripping on a silent-but-live client, since the browser auto-pong
-        // is the only thing such a client emits.
-        ws.on("message", (data) => {
-            session.lastReceivedAt = Date.now();
-            this.handleMessage(session, data.toString()).catch((err) => {
-                logger.error(err, "Message handler error");
-            });
-        });
-        ws.on("ping", () => { session.lastReceivedAt = Date.now(); });
-        ws.on("pong", () => { session.lastReceivedAt = Date.now(); });
-        this.startSessionHeartbeat(session);
-        ws.on("close", (code) => {
-            logger.info(`Connection closed: ${session.id}, code: ${code}`);
-            this.clearSessionTimers(session);
-            this.handleDisconnect(session);
-            this.sessions.delete(ws);
-            this.stats.activeConnections--;
-        });
-        ws.on("error", (err) => {
-            logger.error(err, "Websocket error");
-        });
-    }
-    async handleMessage(session, message) {
-        try {
-            const rawMsg = JSON.parse(message);
-            const parseResult = ClientMessageSchema.safeParse(rawMsg);
-            if (!parseResult.success) {
-                this.sendError(session, "", "Invalid message format", "INVALID_MESSAGE");
-                return;
-            }
-            await this.processMessage(session, parseResult.data);
-        }
-        catch (err) {
-            logger.error(err, "Message handling error");
-            this.sendError(session, "", "Parse error", "PARSE_ERROR");
-        }
-    }
-    async processMessage(session, msg) {
-        switch (msg.type) {
-            case "auth":
-                await this.handleAuth(session, msg.data);
-                break;
-            case "call":
-                await this.handleCall(session, msg.id, msg.procedure, msg.input);
-                break;
-            case "subscribe":
-                await this.handleSubscribe(session, msg.id, msg.procedure, msg.input);
-                break;
-            case "unsubscribe":
-                await this.handleUnsubscribe(session, msg.subId);
-                break;
-        }
-    }
-    async handleAuth(session, data) {
-        if (!this.config.verifyAuth || !data) {
-            this.sendMessage(session, { type: "auth:success", userId: "anonymous" });
-            return;
-        }
-        try {
-            const authResult = await this.config.verifyAuth(data, session.id);
-            if (!authResult) {
-                this.sendMessage(session, { type: "auth:failed", message: "Invalid authentication" });
-                return;
-            }
-            session.serverCtx = authResult;
-            this.sendMessage(session, { type: "auth:success", userId: authResult.user.userId });
-        }
-        catch (e) {
-            if (e instanceof AuthenticationError) {
-                this.sendMessage(session, {
-                    type: "auth:failed",
-                    message: "Invalid authentication: " + e.message,
-                    extra: e.extra,
-                });
-            }
-            else {
-                this.sendMessage(session, { type: "auth:failed", message: "Invalid authentication" });
-            }
-        }
-    }
-    /**
-     * Park a mutation on this session's FIFO queue and resolve when it
-     * eventually drains. The drainer is fire-and-forget: it picks up any
-     * newly enqueued op as long as one drain loop is running on this
-     * session. Callers (handleCall) own the response/error for their own
-     * op via the returned promise.
-     */
-    enqueueMutation(session, procedure, validatedInput) {
-        return new Promise((resolve, reject) => {
-            const pending = {
-                procedure,
-                validatedInput,
-                resolve,
-                reject,
-            };
-            session.mutationQueue.push(pending);
-            this.drainMutationQueue(session).catch((err) => logger.error(err, "drainMutationQueue crashed"));
-        });
-    }
-    /**
-     * Drain the per-session mutation queue serially. Only one drain loop
-     * runs at a time per session — re-entrant calls bail immediately, the
-     * loop already in progress will pick up the new op before exiting.
-     */
-    async drainMutationQueue(session) {
-        if (session.mutationInFlight)
-            return;
-        session.mutationInFlight = true;
-        try {
-            while (session.mutationQueue.length > 0) {
-                const op = session.mutationQueue.shift();
-                try {
-                    const fn = op.procedure.fn;
-                    const result = await this.db.mutation(async (ctx) => {
-                        return fn({ db: ctx, serverCtx: session.serverCtx }, op.validatedInput);
-                    });
-                    op.resolve(result);
-                }
-                catch (err) {
-                    op.reject(err);
-                }
-            }
-        }
-        finally {
-            session.mutationInFlight = false;
-        }
-    }
-    async handleCall(session, id, procedureName, input) {
-        if (!this.router) {
-            this.sendError(session, id, "Router not registered", "SERVER_ERROR");
-            return;
-        }
-        const procedure = this.contextRegistry.getProcedure(procedureName);
-        if (!procedure) {
-            this.sendError(session, id, `Procedure "${procedureName}" not found`, "NOT_FOUND");
-            return;
-        }
-        try {
-            const validatedInput = procedure.inputSchema.parse(input);
-            if (procedure.type === "query") {
-                const result = await this.db.query(async (ctx) => {
-                    const fn = procedure.fn;
-                    return fn({ db: ctx, serverCtx: session.serverCtx }, validatedInput);
-                });
-                this.sendMessage(session, {
-                    type: "response",
-                    id: id,
-                    success: true,
-                    data: result,
-                });
-            }
-            else if (procedure.type === "mutation") {
-                if (session.mutationQueue.length >= MAX_MUTATION_QUEUE_BUFFER) {
-                    this.sendError(session, id, `Too many concurrent mutations on this connection (max ${MAX_MUTATION_QUEUE_BUFFER})`, "TOO_MANY_CONCURRENT_MUTATIONS");
-                    return;
-                }
-                const mutationResult = await this.enqueueMutation(session, procedure, validatedInput);
-                this.sendMessage(session, {
-                    type: "response",
-                    id: id,
-                    success: true,
-                });
-                await this.handleMutationCommit(mutationResult.writeSet, mutationResult.commitTs);
-            }
-            else if (procedure.type === "action") {
-                if (session.actionInFlight >= MAX_ACTION_CONCURRENCY) {
-                    this.sendError(session, id, `Too many concurrent actions on this connection (max ${MAX_ACTION_CONCURRENCY})`, "TOO_MANY_CONCURRENT_ACTIONS");
-                    return;
-                }
-                session.actionInFlight++;
-                let result;
-                try {
-                    const fn = procedure.fn;
-                    result = await fn({ db: this.db, serverCtx: session.serverCtx }, validatedInput);
-                }
-                finally {
-                    session.actionInFlight--;
-                }
-                this.sendMessage(session, {
-                    type: "response",
-                    id: id,
-                    success: true,
-                    data: result,
-                });
-            }
-        }
-        catch (err) {
-            logger.error(err, `Error executing "${procedureName}"`);
-            this.sendError(session, id, err instanceof Error ? err.message : "Execution failed", "EXECUTION_ERROR");
-        }
-    }
-    async handleSubscribe(session, id, procedureName, input) {
-        if (!this.router) {
-            this.sendError(session, id, "Router not registered", "SERVER_ERROR");
-            return;
-        }
-        const procedure = this.contextRegistry.getProcedure(procedureName);
-        if (!procedure || procedure.type !== "query") {
-            this.sendError(session, id, `Procedure "${procedureName}" not found or not a query`, "NOT_FOUND");
-            return;
-        }
-        try {
-            const validatedInput = procedure.inputSchema.parse(input);
-            const queryIdentity = this.resolveQueryIdentity(procedure, session, validatedInput);
-            const inputJsonStable = stableStringify(validatedInput);
-            const subId = await generateSubscriptionId(procedureName, inputJsonStable, queryIdentity);
-            const cacheKey = await generateCacheKey(procedureName, inputJsonStable, queryIdentity);
-            const existingServerSub = this.serverSubscriptions.get(subId);
-            let data;
-            let dataHash;
-            let liveResult = null;
-            // track this session subscribed this subscription
-            session.subIds.add(subId);
-            if (existingServerSub) {
-                existingServerSub.subscribedTimes += 1;
-                const cached = await this.cache.getQueryCacheFor(existingServerSub.cacheKey);
-                if (cached) {
-                    data = cached.data;
-                }
-                else {
-                    liveResult = await this.executeLiveQuery(procedureName, validatedInput, session.serverCtx);
-                    data = liveResult.data;
-                }
-            }
-            else {
-                const lastSnapshotTs = await this.db.impl.getLatestSnapshotTimestamp();
-                const subManagerResult = await this.subManagerClient.registerSubscription({
-                    subId,
-                    cacheKey,
-                    queryName: procedureName,
-                    args: validatedInput,
-                    queryIdentity,
-                    instanceName: this.instanceId,
-                    lastSnapshotTs: lastSnapshotTs,
-                });
-                const cached = await this.cache.getQueryCacheFor(subManagerResult.cacheKey);
-                if (cached && !subManagerResult.recompute) {
-                    data = cached.data;
-                }
-                else {
-                    liveResult = await this.executeLiveQuery(procedureName, validatedInput, session.serverCtx);
-                    data = liveResult.data;
-                }
-                this.serverSubscriptions.set(subId, {
-                    subId,
-                    cacheKey,
-                    subscribedTimes: 1,
-                });
-                this.stats.activeSubscriptions++;
-            }
-            if (liveResult) {
-                const [updateResult] = await Promise.all([
-                    this.subManagerClient.updateSubscriptionReadSet({
-                        cacheKey,
-                        subId,
-                        lastSnapshotTs: liveResult.ts,
-                        readSet: liveResult.readSet,
-                        instanceName: this.instanceId,
-                    }),
-                    this.cache.setQueryCacheFor(cacheKey, data),
-                ]);
-                // If the sub-manager just told us this subId isn't tracked (we hit
-                // a window between its register and a separate restart), our register
-                // above should have rebuilt the state — log loudly if not.
-                if (!updateResult.tracked) {
-                    logger.warn(`updateSubscriptionReadSet returned tracked:false immediately after register for ${subId} ` +
-                        `— possible sub-manager restart mid-subscribe`);
-                }
-            }
-            dataHash = await getHashOf(data);
-            // Hand the canonical subId back to the client so it doesn't need to
-            // recompute the hash locally (which would require pulling in wasm and
-            // wouldn't reflect per-procedure `queryIdentity` overrides).
-            this.sendMessage(session, { type: "response", id, success: true, subId });
-            this.sendMessage(session, { type: "sub:update", subId, data, dataHash });
-            logger.info(`Subscribed: ${subId} for session ${session.id}`);
-        }
-        catch (err) {
-            logger.error(err, `Error subscribing to "${procedureName}"`);
-            this.sendMessage(session, { type: "response", id, success: false });
-            this.sendError(session, id, err instanceof Error ? err.message : "Subscribe failed", "SUBSCRIBE_ERROR");
-        }
-    }
-    async handleUnsubscribe(session, subId) {
-        const serverSub = this.serverSubscriptions.get(subId);
-        if (!serverSub) {
-            session.subIds.delete(subId);
-            return;
-        }
-        serverSub.subscribedTimes -= 1;
-        if (serverSub.subscribedTimes <= 0) {
-            session.subIds.delete(subId);
-            this.serverSubscriptions.delete(subId);
-            this.stats.activeSubscriptions--;
-            try {
-                await this.subManagerClient.unregisterSubscription({ subId, instanceName: this.instanceId });
-            }
-            catch (err) {
-                logger.error(err, "Failed to unregister from sub-manager:");
-            }
-        }
-        logger.info(`Unsubscribed: ${subId} for session ${session.id}, remaining server subs: ${serverSub.subscribedTimes}`);
-    }
-    async handleDisconnect(session) {
-        logger.info(`Session disconnected: ${session.id}`);
-        let unregisterSubs = undefined;
-        for (const subId of session.subIds) {
-            const sub = this.serverSubscriptions.get(subId);
-            if (!sub)
-                continue;
-            sub.subscribedTimes -= 1;
-            if (sub.subscribedTimes <= 0) {
-                if (!unregisterSubs) {
-                    unregisterSubs = [];
-                }
-                unregisterSubs.push(sub);
-            }
-        }
-        if (!unregisterSubs || unregisterSubs.length === 0)
-            return;
-        try {
-            await this.subManagerClient.unregisterSubscriptions(unregisterSubs.map((sub) => ({ subId: sub.subId, instanceName: this.instanceId })));
-        }
-        catch (err) {
-            logger.error(err, "Failed to unregister from sub-manager:");
-        }
-        for (const sub of unregisterSubs) {
-            // if still not subscribing
-            if (sub.subscribedTimes <= 0) {
-                this.serverSubscriptions.delete(sub.subId);
-                this.stats.activeSubscriptions--;
-            }
-        }
-        logger.info(`All Subscription sessions is disconnected: ${session.id}, subs: ${unregisterSubs.length}`);
-    }
-    /**
-     * Drives recovery on a sub-manager reconnect. Iterates this app server's
-     * `serverSubscriptions`, reads each subId's registration record from
-     * Redis (`sl:reg:<subId>`), and re-registers it with the sub-manager.
-     *
-     * • If the Redis record is missing, another app-server instance fully
-     *   unregistered the sub during our disconnect. We drop it locally and
-     *   send `sub:gone` to every session that was holding it.
-     * • If the sub-manager reports `recompute: true` (cache-metadata + commit
-     *   log replay detected staleness), we kick a reexec for that sub.
-     *
-     * Returns after all subs have been processed. Only then does the
-     * SubManagerClient flush its buffered invalidate writeSets.
-     */
-    async runSubManagerRecovery() {
-        const snapshot = Array.from(this.serverSubscriptions.values());
-        if (snapshot.length === 0) {
-            logger.info("Sub-manager recovery: no subscriptions to restore");
-            return;
-        }
-        logger.info(`Sub-manager recovery: restoring ${snapshot.length} subscription(s)`);
-        const lastSnapshotTs = await this.db.impl.getLatestSnapshotTimestamp();
-        const subIds = snapshot.map((e) => e.subId);
-        const recordsMap = await this.cache.fetchRegistrationRecordsBatch(subIds);
-        const registerParams = [];
-        for (const entry of snapshot) {
-            const record = recordsMap.get(entry.subId) ?? null;
-            if (!record) {
-                this.dropSubscriptionLocally(entry.subId, "registration not found after recovery");
-                continue;
-            }
-            registerParams.push({ entry, record });
-        }
-        const recompute = [];
-        const BATCH_SIZE = 50;
-        for (let i = 0; i < registerParams.length; i += BATCH_SIZE) {
-            const batch = registerParams.slice(i, i + BATCH_SIZE);
-            const params = batch.map(({ entry, record }) => ({
-                subId: entry.subId,
-                cacheKey: entry.cacheKey,
-                queryName: record.queryName,
-                args: record.args,
-                queryIdentity: record.queryIdentity,
-                instanceName: this.instanceId,
-                lastSnapshotTs,
-            }));
-            try {
-                const results = await this.subManagerClient.registerSubscriptionBatch(params);
-                for (let j = 0; j < batch.length; j++) {
-                    const { entry, record } = batch[j];
-                    const result = results[j];
-                    if (result.recompute) {
-                        recompute.push({
-                            subId: entry.subId,
-                            queryName: record.queryName,
-                            args: record.args,
-                            cacheKey: entry.cacheKey,
-                            notifyInstances: [],
-                        });
-                    }
-                }
-            }
-            catch (err) {
-                logger.error(err, `Sub-manager recovery: failed to batch register ${i}-${i + batch.length}`);
-            }
-        }
-        await Promise.allSettled(recompute.map((a) => this.reexecuteAffectedQuery(a)));
-        logger.info(`Sub-manager recovery: done (${recompute.length} reexec'd)`);
-    }
-    async runAffectedHandler(affected) {
-        await Promise.allSettled(affected.map((a) => this.reexecuteAffectedQuery(a)));
-    }
-    /**
-     * Removes a subscription from this app server's state and notifies every
-     * session that was holding it. Used during recovery when the central
-     * registration record is gone, or after a `tracked: false` reply from the
-     * sub-manager that we can't reconcile.
-     */
-    dropSubscriptionLocally(subId, reason) {
-        const serverSub = this.serverSubscriptions.get(subId);
-        let notified = 0;
-        if (serverSub) {
-            this.serverSubscriptions.delete(subId);
-            this.stats.activeSubscriptions = Math.max(0, this.stats.activeSubscriptions - 1);
-            for (const [, session] of this.sessions) {
-                if (session.subIds.has(subId)) {
-                    notified++;
-                    session.subIds.delete(subId);
-                    this.sendMessage(session, { type: "sub:gone", subId, reason });
-                }
-            }
-        }
-        logger.warn(`Dropped subscription ${subId} locally (${reason}); notified ${notified} session(s)`);
-    }
-    async handleMutationCommit(writeSet, commitTs) {
-        if (writeSet.length === 0)
-            return;
-        const tables = [...new Set(writeSet.map((w) => w.table))];
-        logger.debug(`Mutation committed for tables: [${tables.join(", ")}]`);
-        try {
-            const result = await this.subManagerClient.invalidateWriteset({ writeSet });
-            logger.debug({ affected: result }, "Sub-managers invalidation result");
-            if (result?.affected?.length > 0) {
-                await Promise.allSettled(result.affected.map((affected) => this.dispatchAffected(affected, commitTs)));
-            }
-        }
-        catch (err) {
-            logger.error(err, "Failed to notify sub-managers");
-        }
-    }
-    /**
-     * Route an affected sub to whichever instance can actually run the
-     * recompute:
-     *   • If this instance has a local session for the sub, recompute here
-     *     (fast path) and broadcast the result to every other instance.
-     *   • Otherwise broadcast a `recompute-race` to every instance in
-     *     `notifyInstances`. Each receiver tries to acquire a Redis lock
-     *     keyed by (subId, commitTs); the winner recomputes and publishes
-     *     an `update` via the normal broadcast path, losers no-op.
-     *
-     * If `notifyInstances` is empty (the sub has no live holders), we drop
-     * the message — the next subscribe will recompute fresh state.
-     */
-    async dispatchAffected(affected, commitTs) {
-        if (this.hasLocalSessionFor(affected.subId)) {
-            await this.reexecuteAffectedQuery(affected);
-            return;
-        }
-        if (affected.notifyInstances.length === 0) {
-            logger.debug(`dispatchAffected: no live instances hold ${affected.subId} — dropping`);
-            return;
-        }
-        await this.publishRecomputeRace(affected, commitTs);
-    }
-    hasLocalSessionFor(subId) {
-        for (const [, session] of this.sessions) {
-            if (session.subIds.has(subId))
-                return true;
-        }
-        return false;
-    }
-    async publishRecomputeRace(affected, commitTs) {
-        const payload = supaliveStringify({
-            type: "recompute-race",
-            subId: affected.subId,
-            cacheKey: affected.cacheKey,
-            queryName: affected.queryName,
-            args: affected.args,
-            notifyInstances: affected.notifyInstances,
-            commitTs: commitTs.toString(),
-            originInstance: this.instanceId,
-        });
-        const publishPromises = affected.notifyInstances.map(async (instance) => {
-            if (instance === this.instanceId)
-                return;
-            const channel = `sub:instance:${instance}`;
-            try {
-                await redisRetryPolicy.execute(() => this.cache.redis.publish(channel, payload));
-            }
-            catch (err) {
-                logger.error(err, `Failed to publish recompute-race to ${channel} after many retries`);
-            }
-        });
-        await Promise.all(publishPromises);
-    }
-    async reexecuteAffectedQuery(affected) {
-        let foundSession = null;
-        for (const [, session] of this.sessions) {
-            if (session.subIds.has(affected.subId)) {
-                foundSession = session;
-                break;
-            }
-        }
-        if (!foundSession) {
-            // Should only happen if every local session unsubscribed between
-            // dispatchAffected's check and now. dispatchAffected forwards to
-            // another instance when no local session exists, so we'd lose the
-            // update for everyone in this rare race. Accept the gap.
-            logger.debug(`Session not found for subId: ${affected.subId}`);
-            return;
-        }
-        try {
-            const liveResult = await this.executeLiveQuery(affected.queryName, affected.args, foundSession.serverCtx);
-            const dataHash = await getHashOf(liveResult.data);
-            const [updateResult] = await Promise.all([
-                this.subManagerClient.updateSubscriptionReadSet({
-                    cacheKey: affected.cacheKey,
-                    subId: affected.subId,
-                    lastSnapshotTs: liveResult.ts,
-                    readSet: liveResult.readSet,
-                    instanceName: this.instanceId,
-                }),
-                this.cache.setQueryCacheFor(affected.cacheKey, liveResult.data),
-            ]);
-            // `tracked: false` means the sub-manager has no record of this subId
-            // (it restarted before we recovered, or a concurrent unregister wiped
-            // it). Drop the sub locally and let clients re-subscribe.
-            if (!updateResult.tracked) {
-                this.dropSubscriptionLocally(affected.subId, "no longer tracked by sub-manager");
-                return;
-            }
-            // find any session with same subId and send update
-            for (const [, session] of this.sessions) {
-                if (session.subIds.has(affected.subId)) {
-                    this.sendMessage(session, {
-                        type: "sub:update",
-                        subId: affected.subId,
-                        data: liveResult.data,
-                        dataHash,
-                    });
-                }
-            }
-            if (affected.notifyInstances.length > 0) {
-                await this.publishSubscriptionUpdate(affected.subId, liveResult.data, dataHash, affected.notifyInstances);
-            }
-            logger.debug(`Re-executed affected query for subId: ${affected.subId}`);
-        }
-        catch (err) {
-            logger.error(err, `Failed to re-execute query for subId ${affected.subId}`);
-        }
-    }
-    async executeLiveQuery(procedureName, input, serverCtx) {
-        const procedure = this.contextRegistry.getProcedure(procedureName);
-        if (!procedure || procedure.type !== "query") {
-            throw new Error(`Procedure not defined: ${procedureName}`);
-        }
-        return this.db.liveQuery(async (ctx) => {
-            const fn = procedure.fn;
-            return fn({ db: ctx, serverCtx }, input);
-        });
-    }
-    /**
-     * Resolve the segmentation key used in the subId/cacheKey hash for a
-     * query subscription. Priority:
-     *
-     *   1. Procedure-level `queryIdentity` override:
-     *        - `false`       → identity = `ANONYMOUS_IDENTITY` (cache shared across users)
-     *        - `string`      → that literal
-     *        - `function`    → ctx + input → string | null | undefined
-     *   2. `config.getUserId(serverCtx)` → falls back to ANONYMOUS_IDENTITY if it
-     *      returns null/undefined or isn't configured.
-     */
-    resolveQueryIdentity(procedure, session, input) {
-        const override = procedure.queryIdentity;
-        if (override !== undefined) {
-            if (override === false)
-                return ANONYMOUS_IDENTITY;
-            if (typeof override === "string")
-                return override;
-            if (typeof override === "function") {
-                const value = override(session.serverCtx, input);
-                if (value === null || value === undefined)
-                    return ANONYMOUS_IDENTITY;
-                return value;
-            }
-        }
-        if (!this.config.getUserId)
-            return ANONYMOUS_IDENTITY;
-        return this.config.getUserId(session.serverCtx) ?? ANONYMOUS_IDENTITY;
-    }
-    sendMessage(session, message) {
-        if (session.ws.readyState !== WebSocket.OPEN)
-            return;
-        session.ws.send(supaliveStringify(message));
-        // Mark the channel as having had recent outbound traffic. The
-        // heartbeat tick uses this to skip the idle-only app-level ping
-        // for busy sessions (no point pinging a client that just got a
-        // sub:update).
-        session.lastSentAt = Date.now();
-    }
-    sendMessageRaw(session, message) {
-        if (session.ws.readyState === WebSocket.OPEN) {
-            session.ws.send(message);
-        }
-    }
-    sendError(session, id, error, code) {
-        this.sendMessage(session, { type: "response", id, success: false, error, code });
-    }
-    async subscribeToInstanceChannel() {
-        const instanceChannel = `sub:instance:${this.instanceId}`;
-        const schemaChannel = SCHEMA_RELOAD_CHANNEL;
-        await this.redisSub.subscribe(instanceChannel, schemaChannel);
-        this.redisSub.on("message", (channel, message) => {
-            if (channel === instanceChannel) {
-                this.handleRemoteInstanceMessage(message).catch((err) => {
-                    logger.error(err, "Error handling remote instance message");
-                });
-            }
-            else if (channel === schemaChannel) {
-                this.handleSchemaReload().catch((err) => {
-                    logger.error(err, "Error handling schema reload");
-                });
-            }
-        });
-        this.redisSub.on("error", (err) => logger.error(err, `Subscriber error for channels: ${instanceChannel}, ${schemaChannel}`));
-        logger.info(`Subscribed to Redis channels: ${instanceChannel}, ${schemaChannel}`);
-    }
-    /**
-     * React to a `schema:reload` broadcast: invalidate the in-memory column
-     * type cache for the named tables (or all if omitted) and re-bootstrap
-     * from Postgres so subsequent batched writes see the fresh types. Skips
-     * messages published by this instance (we already have the new types).
-     */
-    async handleSchemaReload() {
-        logger.info(`Schema reload request received in instance ${this.instanceId} — reloading schema...`);
-        try {
-            await sleep(1000 + (Math.random() * 5000)); // jitter to avoid thundering herd if many instances
-            await this.bootstrapDbTypes(true);
-            logger.info(`Schema reload applied in instance ${this.instanceId}`);
-        }
-        catch (err) {
-            logger.error(err, "Failed to reload schema");
-            return;
-        }
-    }
-    /**
-     * Broadcast a schema-reload signal to every server instance (including
-     * this one — the handler skips self-originated messages, so calling
-     * after a local migration is safe). Pass `tables` to scope the reload;
-     * omit to flush everyone's cache.
-     */
-    async publishSchemaReload(tables) {
-        const payload = JSON.stringify({
-            type: "schema:reload",
-            tables,
-            originInstance: this.instanceId,
-        });
-        await redisRetryPolicy.execute(() => this.cache.redis.publish(SCHEMA_RELOAD_CHANNEL, payload));
-    }
-    async handleRemoteInstanceMessage(message) {
-        let parsed;
-        try {
-            parsed = RemoteSubscriptionMessageSchema.parse(JSON.parse(message));
-        }
-        catch (err) {
-            logger.error(err, "Failed to parse remote instance message");
-            return;
-        }
-        if (parsed.originInstance === this.instanceId)
-            return;
-        if (parsed.type === "update") {
-            for (const [, session] of this.sessions) {
-                if (!session.subIds.has(parsed.subId))
-                    continue;
-                const subEntry = this.serverSubscriptions.get(parsed.subId);
-                if (!subEntry)
-                    continue;
-                this.sendMessage(session, {
-                    type: "sub:update",
-                    subId: parsed.subId,
-                    data: parsed.data,
-                    dataHash: parsed.dataHash,
-                });
-            }
-            return;
-        }
-        // type === "recompute-race" — writer didn't hold the sub locally and
-        // broadcast a race hint to every notifyInstance. The first to acquire
-        // the lock recomputes; the rest no-op.
-        await this.handleRemoteRecomputeRace(parsed);
-    }
-    async handleRemoteRecomputeRace(req) {
-        if (!this.hasLocalSessionFor(req.subId)) {
-            // We're in notifyInstances per sub-manager but the sub has since
-            // been dropped here. Another holder may still pick it up — no warn.
-            return;
-        }
-        const won = await this.cache.tryAcquireRecomputeLock(this.instanceId, req.subId, req.commitTs, RECOMPUTE_LOCK_TTL_SECONDS);
-        if (!won) {
-            logger.debug(`recompute-race: lost lock for ${req.subId}@${req.commitTs}, waiting for winner's update`);
-            return;
-        }
-        await this.reexecuteAffectedQuery({
-            subId: req.subId,
-            queryName: req.queryName,
-            args: req.args,
-            cacheKey: req.cacheKey,
-            notifyInstances: req.notifyInstances,
-        });
-    }
-    async publishSubscriptionUpdate(subId, data, dataHash, notifyInstances) {
-        const payload = supaliveStringify({
-            type: "update",
-            subId,
-            data,
-            dataHash,
-            originInstance: this.instanceId,
-        });
-        const publishPromises = notifyInstances.map(async (instance) => {
-            if (instance === this.instanceId)
-                return;
-            const channel = `sub:instance:${instance}`;
-            try {
-                await redisRetryPolicy.execute(() => this.cache.redis.publish(channel, payload));
-            }
-            catch (err) {
-                logger.error(err, `Failed to publish to ${channel} after many retries`);
-            }
-        });
-        await Promise.all(publishPromises);
-    }
-}
-//# sourceMappingURL=supalive-server.js.map