@supalive/core 1.9.0 → 1.11.0

package/dist/src/exports/server.js

@@ -1,10 +1,10 @@
 import { n as getContextRegistry } from "../../router-CiWYeWUR.js";
 import { n as stableStringify, r as supaliveStringify, t as groupByToMap } from "../../helper-wGbzz6zo.js";
-import { r as evaluateCacheFreshness } from "../../overlap-checker-BqR9qCfy.js";
+import { r as evaluateCacheFreshness } from "../../overlap-checker-BoWNco2y.js";
 import { i as AuthenticationError, o as ClientMessageSchema } from "../../types_client_rpc-CIsjQQGG.js";
 import { n as RemoteSubscriptionMessageSchema } from "../../types_server-Dk6o_B7N.js";
 import { n as sleep } from "../../realtime_db-DiYQbfeA.js";
-import { C as RetentionWatermark, D as logger, E as logLevelOf, O as serializeMapValue, S as RETENTION_WATERMARK_CHANNEL, T as isProduction, _ as UnregisterSubscriptionResultSchema, a as createDatabase, b as UpdateSubscriptionReadSetParamsSchema, c as initDatabase, d as InvalidateWritesetResultSchema, g as UnregisterSubscriptionParamsSchema, h as RegisterSubscriptionResultSchema, i as bootstrapDbTypes, l as CacheLayer, m as RegisterSubscriptionParamsSchema, n as CORE_VERSION, o as initCacheLayer, p as RegisterSubscriptionBatchResultSchema, r as DB_QUERY_TIMEOUT_MS, s as initCore, u as InvalidateWritesetParamsSchema, w as appInstanceId, x as UpdateSubscriptionReadSetResultSchema, y as UnregisterSubscriptionsResultSchema } from "../../subscription-worker-DC9v3_Xn.js";
+import { C as appInstanceId, D as serializeMapValue, E as logger, S as RetentionWatermark, T as logLevelOf, _ as UnregisterSubscriptionResultSchema, a as bootstrapDbTypes, b as UpdateSubscriptionReadSetResultSchema, c as initCore, d as InvalidateWritesetParamsSchema, f as InvalidateWritesetResultSchema, g as UnregisterSubscriptionParamsSchema, h as RegisterSubscriptionResultSchema, i as DB_QUERY_TIMEOUT_MS, l as initDatabase, m as RegisterSubscriptionParamsSchema, n as SubscriptionWorker, o as createDatabase, p as RegisterSubscriptionBatchResultSchema, r as CORE_VERSION, s as initCacheLayer, t as dispatchWorkerMessage, u as CacheLayer, v as UnregisterSubscriptionsResultSchema, w as isProduction, x as RETENTION_WATERMARK_CHANNEL, y as UpdateSubscriptionReadSetParamsSchema } from "../../sub-worker-dispatch-DohrszOw.js";
 import { createServer } from "http";
 import { WebSocket, WebSocketServer } from "ws";
 import { v4 } from "uuid";
@@ -101,7 +101,14 @@ async function runCachedQuery(deps, procedure, procedureName, input, serverCtx,
 	const metadata = await deps.cache.getQueryCacheMetaData(cacheKey);
 	if ((await evaluateCacheFreshness(deps.db.impl, metadata, lastSnapshotTs, deps.getMinRetainedTs())).fresh) {
 		const cached = await deps.cache.getQueryCacheFor(cacheKey);
-		if (cached && metadata && cached.version === metadata.version) return cached.data;
+		if (cached && metadata && cached.version === metadata.version) {
+			if (lastSnapshotTs > metadata.lastSnapshotTs) deps.cache.advanceQueryCacheMetadata(cacheKey, {
+				lastSnapshotTs,
+				version: metadata.version,
+				readSet: metadata.readSet
+			}).catch((err) => logger.error(err, "one-shot horizon advance failed"));
+			return cached.data;
+		}
 	}
 	const result = await deps.db.queryInternal(async (ctx) => {
 		const fn = procedure.fn;
@@ -118,7 +125,7 @@ async function runCachedQuery(deps, procedure, procedureName, input, serverCtx,
 	return result.data;
 }
 //#endregion
-//#region src/server/subscription-manager-client.ts
+//#region src/server/sub-manager-client.ts
 const logger$5 = logger.child({ name: "SUBS_MGR_CLIENT" }, { level: logLevelOf("SUB_MANAGER_CLIENT_LOG_LEVEL") });
 const subscriptionManagerDataPack = {
 	encode: (data) => supaliveStringify(data),
@@ -828,8 +835,9 @@ var SupaliveWebSocketServer = class {
 			...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);
+		if (config.subManager) this.subManagerClient = config.subManager;
+		else if (config.subManagerUrl) this.subManagerClient = new SubManagerClient(config.subManagerUrl);
+		else throw new Error("either `subManager` (in-process link) or `subManagerUrl` (WebSocket URL) is required");
 		this.cache = config.cacheLayer;
 		this.redisSub = config.redisSubClient;
 		this.appPubSubChannels = new Set(config.appPubSub?.channels ?? []);
@@ -1812,12 +1820,12 @@ function fnv1a32(s) {
 	return h >>> 0;
 }
 //#endregion
-//#region src/server/subscription-manager.ts
+//#region src/server/sub-manager.ts
 const logger$1 = logger.child({ name: "SUBS_MGR" }, { level: logLevelOf("SUBS_MANAGER_SERVER_LOG_LEVEL") });
 function resolveWorkerEntry() {
 	const isTs = new URL(import.meta.url).pathname.endsWith(".ts");
 	return {
-		url: new URL(`./subscription-manager-worker-entry${isTs ? ".ts" : ".js"}`, import.meta.url),
+		url: new URL(`./sub-manager-worker-entry${isTs ? ".ts" : ".js"}`, import.meta.url),
 		isTs
 	};
 }
@@ -1826,7 +1834,7 @@ function workerExecArgv(isTs) {
 	if (typeof globalThis.Bun !== "undefined") return void 0;
 	return ["--import", "tsx"];
 }
-var SubscriptionWorkerHandle = class {
+var ThreadWorkerHandle = class {
 	id;
 	worker;
 	pending = /* @__PURE__ */ new Map();
@@ -1881,6 +1889,38 @@ var SubscriptionWorkerHandle = class {
 	}
 };
 /**
+* In-process worker handle: holds a live {@link SubscriptionWorker} and drives
+* it via {@link dispatchWorkerMessage} with `trusted: true`. Every `send` is a
+* direct `await worker.method(payload)` on the main event loop — no
+* `postMessage`, no structured-clone. Used when the manager is embedded in the
+* app server. When `ownsDb` is false the db is borrowed from the host server
+* and is NOT closed on shutdown.
+*/
+var InlineWorkerHandle = class {
+	id;
+	worker;
+	db;
+	ownsDb;
+	constructor(id, worker, db, ownsDb) {
+		this.id = id;
+		this.worker = worker;
+		this.db = db;
+		this.ownsDb = ownsDb;
+	}
+	ready() {
+		return Promise.resolve();
+	}
+	send(type, payload) {
+		return dispatchWorkerMessage(this.worker, this.db, type, payload, { trusted: true });
+	}
+	async shutdown() {
+		if (!this.ownsDb) return;
+		try {
+			await this.db.close();
+		} catch (_) {}
+	}
+};
+/**
 * One process per deployment. Routes each subscription operation to one of N
 * worker threads by hashing subId. Worker threads run in parallel on separate
 * CPU cores; this dispatcher does no Zod parsing — it reads `subId` directly
@@ -1890,28 +1930,72 @@ var SubscriptionWorkerHandle = class {
 var SubscriptionManager = class SubscriptionManager {
 	wss;
 	port;
+	listen;
 	workers;
 	pruneInterval = null;
 	static PRUNE_INTERVAL_MS = 10080 * 60 * 1e3;
 	constructor(config) {
-		this.port = config.port;
-		this.wss = new Server({ port: this.port }, subscriptionManagerDataPack);
-		this.wss.dataPack = subscriptionManagerDataPack;
-		const numWorkers = resolveWorkerCount(config.workers);
-		const maxConnectionsPerWorker = resolveMaxConnectionsPerWorker(config, numWorkers);
-		logger$1.info(`Spawning ${numWorkers} subscription worker${numWorkers === 1 ? "" : "s"}`);
-		this.workers = Array.from({ length: numWorkers }, (_, i) => new SubscriptionWorkerHandle(i + 1, {
-			workerId: i + 1,
-			database: config.database,
-			upstash: config.upstash,
-			cacheTTLSeconds: config.cacheTTLSeconds,
-			maxConnectionsPerWorker
-		}));
-		this.registerMethods();
+		this.listen = config.listen !== false;
+		if (this.listen) {
+			if (config.port == null) throw new Error("SubscriptionManager: `port` is required unless `listen: false`");
+			this.port = config.port;
+			this.wss = new Server({ port: this.port }, subscriptionManagerDataPack);
+			this.wss.dataPack = subscriptionManagerDataPack;
+		}
+		const inline = config.inline === true;
+		let numWorkers = resolveWorkerCount(config.workers);
+		if (inline && numWorkers !== 1) {
+			logger$1.warn(`inline mode runs on the main event loop; forcing workers=1 (was ${numWorkers})`);
+			numWorkers = 1;
+		}
+		if (inline) this.workers = [this.buildInlineWorker(config)];
+		else {
+			if (!config.database || !config.upstash) throw new Error("SubscriptionManager: `database` and `upstash` are required in threaded (non-inline) mode");
+			const maxConnectionsPerWorker = resolveMaxConnectionsPerWorker(config, numWorkers);
+			logger$1.info(`Spawning ${numWorkers} subscription worker${numWorkers === 1 ? "" : "s"}`);
+			this.workers = Array.from({ length: numWorkers }, (_, i) => new ThreadWorkerHandle(i + 1, {
+				workerId: i + 1,
+				database: config.database,
+				upstash: config.upstash,
+				cacheTTLSeconds: config.cacheTTLSeconds,
+				maxConnectionsPerWorker
+			}));
+		}
+		if (this.listen) this.registerMethods();
+	}
+	/**
+	* Build the single in-process worker for {@link SubscriptionManagerConfig.inline}
+	* mode. Reuses the host server's {@link SubscriptionManagerConfig.db} +
+	* {@link SubscriptionManagerConfig.cache} when provided (borrowed — not closed
+	* on stop); otherwise opens its own pool/cache from `database`/`upstash`.
+	*/
+	buildInlineWorker(config) {
+		let db;
+		let cache;
+		let ownsDb;
+		if (config.db && config.cache) {
+			db = config.db;
+			cache = config.cache;
+			ownsDb = false;
+			logger$1.info("Inline subscription worker: reusing host db + cache");
+		} else {
+			if (!config.database || !config.upstash) throw new Error("SubscriptionManager inline mode needs either { db, cache } to reuse, or { database, upstash } to build its own");
+			const { cacheLayer } = initCacheLayer({
+				upstash: config.upstash,
+				cacheTtlSeconds: config.cacheTTLSeconds,
+				commandMaxRetries: 5,
+				createSubClient: false
+			});
+			cache = cacheLayer;
+			db = createDatabase(config.database, 1);
+			ownsDb = true;
+			logger$1.info("Inline subscription worker: built own db + cache");
+		}
+		return new InlineWorkerHandle(1, new SubscriptionWorker(1, cache, db), db, ownsDb);
 	}
 	async start() {
 		await Promise.all(this.workers.map((w) => w.ready()));
-		logger$1.info(`Listening on port ${this.port}`);
+		logger$1.info(this.listen ? `Listening on port ${this.port}` : "Started (embedded, in-process)");
 		try {
 			const minRetainedTs = await this.workers[0].send(12, null);
 			await this.broadcastRetentionWatermark(minRetainedTs);
@@ -1928,10 +2012,29 @@ var SubscriptionManager = class SubscriptionManager {
 			clearInterval(this.pruneInterval);
 			this.pruneInterval = null;
 		}
-		this.wss.close();
+		this.wss?.close();
 		await Promise.all(this.workers.map((w) => w.shutdown()));
 		logger$1.info("Stopped");
 	}
+	/**
+	* A direct, in-process {@link SubManagerLink} to this manager, for embedding
+	* it in the app server (pass as `SupaliveServerConfig.subManager`). Calls the
+	* dispatch handlers directly — no socket, no serialization. The recovery
+	* callbacks are no-ops: an in-process link never disconnects, so the app
+	* server's reconnect/buffer machinery is inert.
+	*/
+	localLink() {
+		return {
+			registerSubscription: (p) => this.registerSubscription(p),
+			registerSubscriptionBatch: (p) => this.registerSubscriptionBatch(p),
+			updateSubscriptionReadSet: (p) => this.updateSubscriptionReadSet(p),
+			unregisterSubscription: (p) => this.unregisterSubscription(p),
+			unregisterSubscriptions: (p) => this.unregisterSubscriptions(p),
+			invalidateWriteset: (p) => this.invalidateWriteset(p),
+			setRecoveryDriver: () => {},
+			setAffectedHandler: () => {}
+		};
+	}
 	async pruneCommitLogs() {
 		const minPerWorker = await Promise.all(this.workers.map((w) => w.send(8, null)));
 		let minRetainedTs = null;
@@ -1964,12 +2067,14 @@ var SubscriptionManager = class SubscriptionManager {
 		return this.workers[this.workerIndexFor(subId)];
 	}
 	registerMethods() {
-		this.wss.register("registerSubscription", this.registerSubscription.bind(this));
-		this.wss.register("registerSubscriptionBatch", this.registerSubscriptionBatch.bind(this));
-		this.wss.register("updateSubscriptionReadSet", this.updateSubscriptionReadSet.bind(this));
-		this.wss.register("invalidateWriteset", this.invalidateWriteset.bind(this));
-		this.wss.register("unregisterSubscription", this.unregisterSubscription.bind(this));
-		this.wss.register("unregisterSubscriptions", this.unregisterSubscriptions.bind(this));
+		const wss = this.wss;
+		if (!wss) return;
+		wss.register("registerSubscription", this.registerSubscription.bind(this));
+		wss.register("registerSubscriptionBatch", this.registerSubscriptionBatch.bind(this));
+		wss.register("updateSubscriptionReadSet", this.updateSubscriptionReadSet.bind(this));
+		wss.register("invalidateWriteset", this.invalidateWriteset.bind(this));
+		wss.register("unregisterSubscription", this.unregisterSubscription.bind(this));
+		wss.register("unregisterSubscriptions", this.unregisterSubscriptions.bind(this));
 	}
 	readSubId(params) {
 		return params.subId;
@@ -2037,7 +2142,7 @@ function resolveWorkerCount(configured) {
 }
 function resolveMaxConnectionsPerWorker(config, workers) {
 	if (config.maxConnectionsPerWorker && config.maxConnectionsPerWorker > 0) return Math.floor(config.maxConnectionsPerWorker);
-	const total = config.database.maxConnections ?? (config.database.type === "mysql" ? 20 : 10);
+	const total = config.database?.maxConnections ?? (config.database?.type === "mysql" ? 20 : 10);
 	return Math.max(1, Math.floor(total / workers));
 }
 //#endregion