@supalive/core 1.18.0 → 1.19.0

package/dist/src/client/index.js

@@ -1,11 +1,11 @@
-import { c as parentConn, i as createActionBuilder, l as primaryOnlyConn, n as getContextRegistry, o as createMutationBuilder, r as router, s as createQueryBuilder } from "../../router-DP2ThAwh.js";
+import { i as createActionBuilder, l as primaryOnlyConn, n as getContextRegistry, o as createMutationBuilder, r as router, s as createQueryBuilder } from "../../router-DP2ThAwh.js";
 import { r as supaliveStringify } from "../../helper-zdJT5FUc.js";
 import { o as matchesPredicate } from "../../query-LJranz0c.js";
 import { n as defineSchema, t as defineComputedField } from "../../schema-DRtz5h5l.js";
 import { C as normalizeIdToBytes, S as bytesFromJson, _ as RawRangeReadSchema, a as DEFAULT_RETRY, b as WriteEntrySchema, c as OccAbortError, d as PointReadSchema, f as PredicateSchema, g as RawPointReadSchema, h as RangeReadSchema, i as CompareOperatorSchema, l as OccConflictError, m as QueryCacheMetadataSchema, n as BigIntSchema, o as LeafPredicateSchema, p as QueryCacheEntrySchema, r as CachedPgMetadataSchema, s as NO_RETRY, t as AndPredicateSchema, u as OrPredicateSchema, v as RawReadEntrySchema, w as normalizeToBytes, x as WriteOpSchema, y as ReadEntrySchema } from "../../types_db-OUou3o2Z.js";
 import { l as ServerMessageSchema } from "../../types_client_rpc-B8jh6MKl.js";
-import { a as TxContext, i as DbWriter, n as sleep, r as DbReader, t as SupaliveDb } from "../../realtime_db-B0Tin87E.js";
-import { n as resolveReadRouting, t as makeConnRouting } from "../../read-routing-BUcQAwnd.js";
+import { c as DbReader, l as DbWriter, o as SupaliveDb, s as sleep, u as TxContext } from "../../logger-DrXccWFZ.js";
+import { n as runCachedQueryInParent, t as runCachedQuery } from "../../one-shot-query-BBiv9LGP.js";
 import { sha1 } from "hash-wasm";
 //#region src/db/query_definition.ts
 const _globalDefs = /* @__PURE__ */ new Map();
@@ -1157,56 +1157,45 @@ var LiveQueryHandleImpl = class {
 //#endregion
 //#region src/client/caller_client.ts
 /**
-* Run a standalone (non-transaction-joining) server-side query with replica
-* routing that DEFAULTS to the primary.
-*
-* Unlike a client one-shot query, the internal caller has no client `minTs`
-* high-water to gate replica staleness — a caller that just performed an
-* internal write and then reads back would silently read a lagging replica. So
-* the safe default here is the PRIMARY; a handler can still opt a heavy
-* reporting read onto the replica with `ctx.useReplicaConn()` (and force back
-* with `ctx.usePrimaryConn()` / `{ readOwnWrite: true }`). The connection knobs
-* use the SAME shared routing rule as the one-shot path ({@link resolveReadRouting}
-* / {@link makeConnRouting}) — the only difference is the DEFAULT connection
-* (primary here, replica-if-caught-up there). With no minTs floor, an explicit
-* `useReplicaConn()` resolves to the replica whenever one is configured. With no
-* replica configured every branch resolves to the primary.
-*/
-async function runRoutedCallerQuery(db, serverCtx, fn, log) {
-	const routing = await resolveReadRouting(db, await db.impl.getLatestSnapshotTimestamp(), 0n);
-	return (await db.queryInternalOn({
-		impl: routing.primaryImpl,
-		beginTs: routing.primaryTs
-	}, async (dbCtx) => {
-		return fn({
-			db: dbCtx,
-			serverCtx,
-			log,
-			...makeConnRouting(dbCtx, routing)
-		});
-	})).data;
-}
-/**
 * Create a server-side caller that bypasses HTTP/WebSocket.
 * 
 * For in-memory calls, input validation is skipped (data is already a JS object).
 * Query procedures also get a liveQuery() method for server-side use.
+*
+* `init` requires the shared Redis-backed query cache, so every read path —
+* `query`, `runQuery`, and `liveQuery` — behaves like a normal client procedure
+* call: it checks cache freshness first and only falls back to executing the
+* query on a miss/stale entry (see runCachedQuery and runCachedQueryInParent).
+* `runQuery` keeps joining the parent snapshot/readSet (or opening a fresh
+* routed read for action/job parents), so nested reads stay consistent with the
+* parent and mutations keep reads-your-writes.
 */
 function createCaller(options) {
 	const { isInternal = true, inContext } = options;
 	const registry = getContextRegistry(inContext ?? "default");
 	const cache = /* @__PURE__ */ new Map();
+	let callerConfig;
 	let db;
 	let storage;
 	let scheduler;
 	let obs;
+	let cacheLayer;
+	let callerDepsInstance;
 	return new Proxy({}, { get(_target, procedureName) {
 		if (typeof procedureName !== "string") return;
 		if (procedureName == "init") return async (config) => {
+			callerConfig = config;
 			db = config.db;
 			storage = config.storage;
 			scheduler = config.scheduler;
 			obs = config.obs;
+			cacheLayer = config.cache;
+			callerDepsInstance = {
+				db: config.db,
+				cache: cacheLayer,
+				getMinRetainedTs: config.getMinRetainedTs,
+				getUserId: config.getUserId
+			};
 		};
 		const callerLog = () => obs.lazyChildLogger({
 			caller: "internal",
@@ -1225,21 +1214,32 @@ function createCaller(options) {
 			query: async (input, serverCtx) => {
 				if (procedure.type !== "query") throw new Error(`Procedure "${procedureName}" is not a query`);
 				const validatedInput = validateInput(input);
-				return runRoutedCallerQuery(db, serverCtx, (ctx) => procedure.fn(ctx, validatedInput), callerLog());
+				const lastSnapshotTs = await db.impl.getLatestSnapshotTimestamp();
+				const { data } = await runCachedQuery(callerDepsInstance, { log: callerLog() }, procedure, procedureName, validatedInput, serverCtx, lastSnapshotTs);
+				return data;
 			},
 			runQuery: async (input, parentCtx) => {
 				if (procedure.type !== "query") throw new Error(`Procedure "${procedureName}" is not a query`);
 				const validatedInput = validateInput(input);
 				if (parentCtx.db instanceof TxContext) {
-					const ctx = {
-						db: parentCtx.db,
-						serverCtx: parentCtx.serverCtx,
+					const parentReader = parentCtx.db;
+					return runCachedQueryInParent(callerDepsInstance, {
 						log: parentCtx.log,
-						...parentConn
-					};
-					return procedure.fn(ctx, validatedInput);
+						span: parentCtx.span
+					}, procedure, procedureName, validatedInput, parentCtx.serverCtx, parentReader);
 				}
-				return runRoutedCallerQuery(parentCtx.db, parentCtx.serverCtx, (ctx) => procedure.fn(ctx, validatedInput), parentCtx.log);
+				const parentDb = parentCtx.db;
+				const lastSnapshotTs = await parentDb.impl.getLatestSnapshotTimestamp();
+				const { data } = await runCachedQuery({
+					db: parentDb,
+					cache: cacheLayer,
+					getMinRetainedTs: callerConfig.getMinRetainedTs,
+					getUserId: callerConfig.getUserId
+				}, {
+					log: parentCtx.log,
+					span: parentCtx.span
+				}, procedure, procedureName, validatedInput, parentCtx.serverCtx, lastSnapshotTs);
+				return data;
 			},
 			mutate: async (input, serverCtx) => {
 				if (procedure.type !== "mutation") throw new Error(`Procedure "${procedureName}" is not a mutation`);
@@ -1262,6 +1262,7 @@ function createCaller(options) {
 						db: dbCtx,
 						serverCtx: parentCtx.serverCtx,
 						log: parentCtx.log,
+						span: parentCtx.span,
 						...primaryOnlyConn
 					};
 					if (parentCtx.db instanceof TxContext) ctx.db.appendInternalReadSet(parentCtx.db.internalGetReadSet());
@@ -1292,15 +1293,9 @@ function createCaller(options) {
 			},
 			liveQuery: procedure.type === "query" ? async (input, serverCtx) => {
 				const validatedInput = validateInput(input);
-				return db.liveQuery(async (dbCtx) => {
-					const ctx = {
-						db: dbCtx,
-						serverCtx,
-						log: callerLog(),
-						...primaryOnlyConn
-					};
-					return procedure.fn(ctx, validatedInput);
-				});
+				const obs = { log: callerLog() };
+				const lastSnapshotTs = await db.impl.getLatestSnapshotTimestamp();
+				return runCachedQuery(callerDepsInstance, obs, procedure, procedureName, validatedInput, serverCtx, lastSnapshotTs);
 			} : void 0
 		};
 		cache.set(procedureName, newProp);