@supalive/core 1.15.0 → 1.17.0

package/dist/realtime_db-DVhhasJj.js

@@ -0,0 +1,312 @@
+import { a as unwrapZodType, i as normalizeCodec } from "./table-id-DyrJBKAQ.js";
+import { s as traceDbCall, t as QueryBuilder } from "./query-q1ZvKrZO.js";
+import { r as LazyCommitTsParam } from "./db-ClCicssQ.js";
+import { l as OccConflictError } from "./types_db-OUou3o2Z.js";
+import { z as z$1 } from "zod";
+import { ExponentialBackoff, handleWhen, retry } from "cockatiel";
+//#region src/db/context.ts
+/**
+* Materialize a schema's runtime {@link Model}: column-name mapping, per-column
+* coarse type tags, and the codec used to (de)serialize each column.
+*
+* Codecs are resolved via {@link normalizeCodec}, which supplies a sensible
+* default per Zod type (e.g. a {@link dateCodec} for `z.date()`, so `Date`
+* columns round-trip automatically) while letting a user-supplied codec in
+* `schema.columnsOptions.codecs` override it — partially or fully.
+*/
+function buildModel(schema) {
+	const shape = schema.schema.shape;
+	const customColumns = schema.columns;
+	const columns = {};
+	const types = {};
+	const codecs = {};
+	const schemaCodecs = schema.columnsOptions.codecs ?? {};
+	for (const key of Object.keys(shape)) {
+		columns[key] = customColumns?.[key] ?? key;
+		const field = shape[key];
+		const baseField = unwrapZodType(field);
+		if (baseField instanceof z$1.ZodNumber) types[key] = "integer";
+		else if (baseField instanceof z$1.ZodString) types[key] = "string";
+		else if (baseField instanceof z$1.ZodBoolean) types[key] = "boolean";
+		else if (baseField instanceof z$1.ZodDate) types[key] = "date";
+		else if (baseField instanceof z$1.ZodArray) types[key] = "array";
+		else types[key] = "json";
+		codecs[key] = normalizeCodec(schemaCodecs[key], baseField);
+	}
+	return {
+		table: schema.table,
+		tableId: schema.tableId,
+		columns,
+		reverseColumns: Object.fromEntries(Object.entries(columns).map(([k, v]) => [v, k])),
+		types,
+		codecs
+	};
+}
+var TxContext = class {
+	beginTs;
+	db;
+	readSet = [];
+	writeSet = [];
+	models = /* @__PURE__ */ new Map();
+	getOrCreateModel(schema) {
+		const existing = this.models.get(schema.table);
+		if (existing) return existing;
+		const model = buildModel(schema);
+		this.models.set(schema.table, model);
+		return model;
+	}
+	constructor(db, beginTs) {
+		this.db = db;
+		this.beginTs = beginTs;
+	}
+	/**
+	* Rebind the read connection (and its snapshot ts). Used by the replica
+	* router when a query handler calls `ctx.usePrimaryConn()`/`useReplicaConn()`.
+	* Must be called BEFORE any read — the readSet/beginTs would otherwise mix
+	* snapshots — so this throws if a read or write has already happened.
+	*/
+	useConnection(db, beginTs) {
+		if (this.readSet.length > 0 || this.writeSet.length > 0) throw new Error("useConnection()/usePrimaryConn()/useReplicaConn() must be called before any read or write in the handler");
+		this.db = db;
+		this.beginTs = beginTs;
+	}
+	internalGetReadSet() {
+		return this.readSet;
+	}
+	internalGetWriteSet() {
+		return this.writeSet;
+	}
+	/**
+	* Merge a parent procedure's reads into this context's readSet. Used when a
+	* `runMutation` sub-transaction inherits the reads of the procedure that
+	* invoked it, so the sub-tx's OCC validation also fences on those rows.
+	* Entries are shallow-cloned so the two readSets don't alias.
+	*/
+	appendInternalReadSet(parentEntries) {
+		this.readSet.push(...parentEntries.map((e) => ({ ...e })));
+	}
+	findPendingWrite(table, id) {
+		return this.writeSet.find((w) => w.table === table && w.id === id);
+	}
+	findPendingInsert(table, id) {
+		return this.writeSet.find((w) => w.table === table && w.id === id && w.op === "insert");
+	}
+	encodeWithCodec(model, property, value) {
+		const codec = model.codecs[property];
+		if (!codec?.encode || value === void 0 || value === null) return value;
+		return codec.encode(value);
+	}
+};
+var DbReader = class extends TxContext {
+	query(schema) {
+		const model = this.getOrCreateModel(schema);
+		return new QueryBuilder(this, model);
+	}
+};
+var DbWriter = class extends DbReader {
+	async insert(schema, id, data) {
+		const model = this.getOrCreateModel(schema);
+		const mappedData = { id };
+		const shape = schema.schema.shape;
+		for (const key of Object.keys(shape)) {
+			let value = data[key];
+			if (value === void 0) {
+				const field = shape[key];
+				if (field instanceof z$1.ZodDefault) {
+					const defaultVal = field.def.defaultValue;
+					value = typeof defaultVal === "function" ? defaultVal() : defaultVal;
+					if (value !== void 0) {
+						const columnName = model.columns[key] ?? key;
+						mappedData[columnName] = this.encodeWithCodec(model, key, value);
+					}
+				}
+			} else {
+				const columnName = model.columns[key] ?? key;
+				mappedData[columnName] = this.encodeWithCodec(model, key, value);
+			}
+		}
+		mappedData["id"] = id;
+		const existing = this.findPendingWrite(schema.table, id);
+		if (existing) if (existing.op === "delete") {
+			existing.op = "update";
+			existing.data = mappedData;
+		} else existing.data = {
+			...existing.data,
+			...mappedData
+		};
+		else this.writeSet.push({
+			table: schema.table,
+			tableId: schema.tableId,
+			id,
+			op: "insert",
+			data: mappedData
+		});
+	}
+	async update(schema, id, data) {
+		const model = this.getOrCreateModel(schema);
+		const mappedData = {};
+		for (const [key, value] of Object.entries(data)) {
+			const columnName = model.columns[key] ?? key;
+			mappedData[columnName] = this.encodeWithCodec(model, key, value);
+		}
+		const existing = this.findPendingWrite(schema.table, id);
+		if (existing) {
+			existing.op = existing.op === "insert" ? "insert" : "update";
+			existing.data = {
+				...existing.data,
+				...mappedData
+			};
+		} else this.writeSet.push({
+			table: schema.table,
+			tableId: schema.tableId,
+			id,
+			op: "update",
+			data: mappedData
+		});
+	}
+	async delete(schema, id) {
+		const existingInsert = this.findPendingInsert(schema.table, id);
+		if (existingInsert) {
+			this.writeSet = this.writeSet.filter((w) => w !== existingInsert);
+			return;
+		}
+		this.writeSet.push({
+			table: schema.table,
+			tableId: schema.tableId,
+			id,
+			op: "delete"
+		});
+	}
+};
+//#endregion
+//#region src/db/realtime_db.ts
+const occRetryPolicy = retry(handleWhen((err) => OccConflictError.isOccConflictError(err)), {
+	maxAttempts: 15,
+	backoff: new ExponentialBackoff({
+		initialDelay: 10,
+		maxDelay: 7e3,
+		exponent: 2
+	})
+});
+const getDbclientRetryPolicy = retry(handleWhen((err) => err.message.includes("timeout exceeded")), {
+	maxAttempts: 3,
+	backoff: new ExponentialBackoff({
+		initialDelay: 500,
+		maxDelay: 2e3,
+		exponent: 2
+	})
+});
+var SupaliveDb = class SupaliveDb {
+	impl;
+	replica;
+	/**
+	* @param impl     the PRIMARY (writer) connection — all mutations, the OCC
+	*                 commit-ts source, and cache-freshness commit-log scans run here.
+	* @param replica  optional read replica for query/action reads (see the
+	*                 routing in one-shot-query.ts). Undefined → reads use primary.
+	*/
+	constructor(impl, replica) {
+		this.impl = impl;
+		this.replica = replica;
+	}
+	static create(config) {
+		return new SupaliveDb(config.db, config.replica ? new SupaliveDb(config.replica) : void 0);
+	}
+	/** True when a distinct read replica is configured. */
+	get hasReplica() {
+		return this.replica !== void 0;
+	}
+	onAfterCommit;
+	/**
+	* Register a hook fired once after every successful `mutation()` commit
+	* (never on an OCC conflict/rollback), with the committed writeSet and its
+	* commitTs. The server uses this to drive subscription invalidation for ALL
+	* mutation sources — client WS calls, actions, jobs, and the internal caller —
+	* so a server-side write pushes live updates just like a client write does.
+	* Non-server consumers (migration tooling, tests) leave it unset (no-op).
+	*/
+	setOnAfterCommit(cb) {
+		this.onAfterCommit = cb;
+	}
+	/**
+	* One-shot read against an EXPLICIT connection + snapshot ts (rather than this
+	* db's own latest). Used by the replica router: the caller pre-resolves the
+	* default read connection (replica for queries) and hands the handler a
+	* `DbReader` it can rebind via `useConnection` (ctx.usePrimaryConn/…). The
+	* returned `ts` is the FINAL bound connection's snapshot, so the cache entry is
+	* stamped with the ts actually read at.
+	*/
+	async queryInternalOn(read, fn) {
+		const ctx = new DbReader(read.impl, read.beginTs);
+		const data = await fn(ctx);
+		return {
+			ts: ctx.beginTs,
+			data,
+			readSet: ctx.internalGetReadSet()
+		};
+	}
+	async query(fn) {
+		const beginTs = await this.impl.getLatestSnapshotTimestamp();
+		return await fn(new DbReader(this.impl, beginTs));
+	}
+	/**
+	* Compute a query once at the latest snapshot, returning the result together
+	* with the snapshot `ts` and the tracked `readSet`. This is a plain one-shot
+	* evaluation — it registers NO live subscription; the `readSet`/`ts` are
+	* returned purely so the caller (e.g. the one-shot query cache) can store
+	* freshness metadata. Use this for cached one-shot query calls (WS `call`,
+	* HTTP RPC). `liveQuery` is the same computation under the subscription path's
+	* name and simply delegates here.
+	*/
+	async queryInternal(fn) {
+		const beginTs = await this.impl.getLatestSnapshotTimestamp();
+		const ctx = new DbReader(this.impl, beginTs);
+		return {
+			ts: beginTs,
+			data: await fn(ctx),
+			readSet: ctx.internalGetReadSet()
+		};
+	}
+	async liveQuery(fn) {
+		return this.queryInternal(fn);
+	}
+	async mutation(fn, retryPolicy = occRetryPolicy) {
+		return await retryPolicy.execute(async (p) => {
+			let db;
+			try {
+				const beginTs = await this.impl.getLatestSnapshotTimestamp() + 1n;
+				const ctx = new DbWriter(this.impl, beginTs);
+				const result = await fn(ctx);
+				const readSet = ctx.internalGetReadSet();
+				const writeSet = ctx.internalGetWriteSet();
+				const commitTsLazy = new LazyCommitTsParam(void 0);
+				await this.impl.attachPrevDataToWriteSet(writeSet, readSet);
+				const queries = await this.impl.prepareCommitWrites(readSet, writeSet, commitTsLazy);
+				db = await getDbclientRetryPolicy.execute(() => this.impl.getTransactionClient());
+				await db.begin();
+				const commitTs = await db.getNextTimestamp();
+				commitTsLazy.value = commitTs;
+				const commitResult = await traceDbCall("commit", "", this.impl.dbType, () => db.commitWrites(beginTs, queries, commitTs));
+				if (!commitResult.success) throw new OccConflictError("Commit failed", { commitResult });
+				await db.updateLatestSnapshotTimestamp(commitTs);
+				await db.commit();
+				this.onAfterCommit?.(writeSet, commitTs);
+				return {
+					result,
+					writeSet,
+					commitTs
+				};
+			} catch (err) {
+				await db?.rollback();
+				throw err;
+			} finally {
+				db?.release();
+			}
+		});
+	}
+};
+const sleep = (ms) => new Promise((res) => setTimeout(res, ms));
+//#endregion
+export { TxContext as a, DbWriter as i, sleep as n, DbReader as r, SupaliveDb as t };
+
+//# sourceMappingURL=realtime_db-DVhhasJj.js.map

package/dist/realtime_db-DVhhasJj.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtime_db-DVhhasJj.js","names":["z"],"sources":["../src/db/context.ts","../src/db/realtime_db.ts"],"sourcesContent":["import { z, ZodRawShape } from \"zod\";\nimport { Database } from \"./db\";\nimport { ReadEntry, WriteEntry, } from \"./types_db\";\n\nimport { ColumnCodec, InferSchema, InsertData, Model, SchemaDefinition } from \"./schema\";\nimport { normalizeCodec, unwrapZodType } from \"./codec\";\nimport { QueryBuilder } from \"./query\";\n\n/**\n * Materialize a schema's runtime {@link Model}: column-name mapping, per-column\n * coarse type tags, and the codec used to (de)serialize each column.\n *\n * Codecs are resolved via {@link normalizeCodec}, which supplies a sensible\n * default per Zod type (e.g. a {@link dateCodec} for `z.date()`, so `Date`\n * columns round-trip automatically) while letting a user-supplied codec in\n * `schema.columnsOptions.codecs` override it — partially or fully.\n */\nexport function buildModel(schema: SchemaDefinition<string, ZodRawShape>): Model {\n  const shape = schema.schema.shape;\n  const customColumns = (schema as any).columns;\n  const columns: Record<string, string> = {};\n  const types: Record<string, string> = {};\n  const codecs: Record<string, ColumnCodec<any, any>> = {};\n  const schemaCodecs = schema.columnsOptions.codecs ?? {};\n\n  for (const key of Object.keys(shape)) {\n    columns[key] = customColumns?.[key] ?? key;\n    const field = shape[key];\n    const baseField = unwrapZodType(field);\n    if (baseField instanceof z.ZodNumber) {\n      types[key] = \"integer\";\n    } else if (baseField instanceof z.ZodString) {\n      types[key] = \"string\";\n    } else if (baseField instanceof z.ZodBoolean) {\n      types[key] = \"boolean\";\n    } else if (baseField instanceof z.ZodDate) {\n      types[key] = \"date\";\n    } else if (baseField instanceof z.ZodArray) {\n      types[key] = \"array\";\n    } else {\n      types[key] = \"json\";\n    }\n    codecs[key] = normalizeCodec(schemaCodecs[key], baseField);\n  }\n\n  return {\n    table: schema.table,\n    tableId: schema.tableId,\n    columns,\n    reverseColumns: Object.fromEntries(Object.entries(columns).map(([k, v]) => [v, k])),\n    types,\n    codecs,\n  };\n}\n\nexport class TxContext {\n  // Not `readonly`: a query's read connection can be rebound (primary↔replica)\n  // via {@link useConnection} before the first read — see the replica routing in\n  // realtime_db.ts / one-shot-query.ts. Mutations never rebind.\n  beginTs: bigint;\n  db: Database;\n  protected readSet: ReadEntry[] = [];\n  protected writeSet: WriteEntry[] = [];\n  private models: Map<string, Model> = new Map();\n\n  protected getOrCreateModel(schema: SchemaDefinition<string, ZodRawShape>): Model {\n    const existing = this.models.get(schema.table);\n    if (existing) return existing;\n\n    const model = buildModel(schema);\n    this.models.set(schema.table, model);\n    return model;\n  }\n\n  constructor(db: Database, beginTs: bigint) {\n    this.db = db;\n    this.beginTs = beginTs;\n  }\n\n  /**\n   * Rebind the read connection (and its snapshot ts). Used by the replica\n   * router when a query handler calls `ctx.usePrimaryConn()`/`useReplicaConn()`.\n   * Must be called BEFORE any read — the readSet/beginTs would otherwise mix\n   * snapshots — so this throws if a read or write has already happened.\n   */\n  useConnection(db: Database, beginTs: bigint): void {\n    if (this.readSet.length > 0 || this.writeSet.length > 0) {\n      throw new Error(\n        \"useConnection()/usePrimaryConn()/useReplicaConn() must be called before any read or write in the handler\",\n      );\n    }\n    this.db = db;\n    this.beginTs = beginTs;\n  }\n\n  internalGetReadSet(): ReadEntry[] { return this.readSet; }\n  internalGetWriteSet(): WriteEntry[] { return this.writeSet; }\n\n  /**\n   * Merge a parent procedure's reads into this context's readSet. Used when a\n   * `runMutation` sub-transaction inherits the reads of the procedure that\n   * invoked it, so the sub-tx's OCC validation also fences on those rows.\n   * Entries are shallow-cloned so the two readSets don't alias.\n   */\n  appendInternalReadSet(parentEntries: ReadEntry[]) {\n    this.readSet.push(...parentEntries.map((e) => ({...e})));\n  }\n\n  protected findPendingWrite(table: string, id: string): WriteEntry | undefined {\n    return this.writeSet.find(w => w.table === table && w.id === id);\n  }\n\n  protected findPendingInsert(table: string, id: string): WriteEntry | undefined {\n    return this.writeSet.find(w => w.table === table && w.id === id && w.op === \"insert\");\n  }\n\n  protected encodeWithCodec(model: Model, property: string, value: unknown): unknown {\n    const codec = model.codecs[property];\n    if (!codec?.encode || value === undefined || value === null) return value;\n    return codec.encode(value);\n  }\n}\n\nexport class DbReader extends TxContext {\n  query<S extends SchemaDefinition<string, ZodRawShape>>(schema: S): QueryBuilder<S> {\n    const model = this.getOrCreateModel(schema);\n    return new QueryBuilder<S>(this, model);\n  }\n}\n\nexport class DbWriter extends DbReader {\n  async insert<S extends SchemaDefinition<string, ZodRawShape>, ID extends string>(\n    schema: S,\n    id: ID,\n    data: InsertData<S>\n  ): Promise<void> {\n    const model = this.getOrCreateModel(schema);\n    const mappedData: Record<string, unknown> = { id };\n    const shape = schema.schema.shape;\n\n    for (const key of Object.keys(shape)) {\n      let value = data[key];\n\n      if (value === undefined) {\n        const field = shape[key];\n        if (field instanceof z.ZodDefault) {\n          const defaultVal = field.def.defaultValue;\n          value = (typeof defaultVal === \"function\" ? defaultVal() : defaultVal)\n\n          if (value !== undefined) {\n            const columnName = model.columns[key] ?? key;\n            mappedData[columnName] = this.encodeWithCodec(model, key, value);\n          }\n        }\n      } else {\n        const columnName = model.columns[key] ?? key;\n        mappedData[columnName] = this.encodeWithCodec(model, key, value);\n      }\n    }\n    // ensure id same\n    mappedData[\"id\"] = id;\n\n    // Check for existing pending write for the same ID\n    const existing = this.findPendingWrite(schema.table, id);\n    if (existing) {\n      if (existing.op === \"delete\") {\n        // If there's a pending delete, change it to an update with the new data\n        existing.op = \"update\";\n        existing.data = mappedData;\n      } else {\n        // If there's a pending update or same insert with the same ID , merge the new data\n        existing.data = { ...existing.data, ...mappedData };\n      }\n    } else {\n      this.writeSet.push({ table: schema.table, tableId: schema.tableId, id: id, op: \"insert\", data: mappedData });\n    }\n  }\n\n  async update<S extends SchemaDefinition<string, ZodRawShape>, ID extends string>(\n    schema: S,\n    id: ID,\n    data: Partial<Omit<InferSchema<S>, \"id\" | \"commitTs\">>,\n  ): Promise<void> {\n    const model = this.getOrCreateModel(schema);\n    const mappedData: Record<string, unknown> = {};\n\n    for (const [key, value] of Object.entries(data)) {\n      const columnName = model.columns[key] ?? key;\n      mappedData[columnName] = this.encodeWithCodec(model, key, value);\n    }\n\n    const existing = this.findPendingWrite(schema.table, id);\n    if (existing) {\n      existing.op = existing.op === \"insert\" ? \"insert\" : \"update\";\n      existing.data = { ...existing.data, ...mappedData };\n    } else {\n      // expectedTs will be filled by the committer via batch fetch if not known yet\n      this.writeSet.push({ table: schema.table, tableId: schema.tableId, id, op: \"update\", data: mappedData });\n    }\n  }\n\n  async delete<S extends SchemaDefinition<string, ZodRawShape>, ID extends string>(\n    schema: S,\n    id: ID,\n  ): Promise<void> {\n    // If there's a pending insert for the same ID, remove it instead of adding a delete\n    const existingInsert = this.findPendingInsert(schema.table, id);\n    if (existingInsert) {\n      this.writeSet = this.writeSet.filter(w => w !== existingInsert);\n      return;\n    }\n\n    // expectedTs will be filled by the committer via batch fetch if not known yet\n    this.writeSet.push({ table: schema.table, tableId: schema.tableId, id, op: \"delete\" });\n  }\n}\n","import { Database, LazyCommitTsParam, TxDatabase } from \"./db\";\nimport {\n  OccConflictError, WriteEntry, CommitTs, LiveResult, MutationResult\n} from \"./types_db\";\nimport { DbReader, DbWriter } from \"./context\";\nimport { traceDbCall } from \"./db-trace\";\nimport { ExponentialBackoff, handleWhen, retry, RetryPolicy } from \"cockatiel\";\n\nexport const occRetryPolicy = retry(\n  handleWhen((err) => OccConflictError.isOccConflictError(err)),\n  {\n    maxAttempts: 15,\n    backoff: new ExponentialBackoff({\n      initialDelay: 10,\n      maxDelay: 7000,\n      exponent: 2,\n    }),\n  },\n);\n\nexport const getDbclientRetryPolicy = retry(\n  handleWhen((err) => err.message.includes('timeout exceeded')),\n  {\n    maxAttempts: 3,\n    backoff: new ExponentialBackoff({\n      initialDelay: 500,\n      maxDelay: 2000,\n      exponent: 2,\n    }),\n  },\n);\n\nexport class SupaliveDb {\n  /**\n   * @param impl     the PRIMARY (writer) connection — all mutations, the OCC\n   *                 commit-ts source, and cache-freshness commit-log scans run here.\n   * @param replica  optional read replica for query/action reads (see the\n   *                 routing in one-shot-query.ts). Undefined → reads use primary.\n   */\n  constructor(readonly impl: Database, readonly replica?: SupaliveDb) { }\n\n  static create(config: { db: Database; replica?: Database }): SupaliveDb {\n    return new SupaliveDb(config.db, config.replica ? new SupaliveDb(config.replica) : undefined);\n  }\n\n  /** True when a distinct read replica is configured. */\n  get hasReplica(): boolean {\n    return this.replica !== undefined;\n  }\n\n  protected onAfterCommit?: (writeSet: WriteEntry[], commitTs: CommitTs) => void;\n\n  /**\n   * Register a hook fired once after every successful `mutation()` commit\n   * (never on an OCC conflict/rollback), with the committed writeSet and its\n   * commitTs. The server uses this to drive subscription invalidation for ALL\n   * mutation sources — client WS calls, actions, jobs, and the internal caller —\n   * so a server-side write pushes live updates just like a client write does.\n   * Non-server consumers (migration tooling, tests) leave it unset (no-op).\n   */\n  setOnAfterCommit(cb: (writeSet: WriteEntry[], commitTs: CommitTs) => void): void {\n    this.onAfterCommit = cb;\n  }\n\n  // ── Read-only query ──────────────────────────────────────────────\n\n  /**\n   * One-shot read against an EXPLICIT connection + snapshot ts (rather than this\n   * db's own latest). Used by the replica router: the caller pre-resolves the\n   * default read connection (replica for queries) and hands the handler a\n   * `DbReader` it can rebind via `useConnection` (ctx.usePrimaryConn/…). The\n   * returned `ts` is the FINAL bound connection's snapshot, so the cache entry is\n   * stamped with the ts actually read at.\n   */\n  async queryInternalOn<T>(\n    read: { impl: Database; beginTs: bigint },\n    fn: (ctx: DbReader) => Promise<T>,\n  ): Promise<LiveResult<T>> {\n    const ctx = new DbReader(read.impl, read.beginTs);\n    const data = await fn(ctx);\n    return { ts: ctx.beginTs, data, readSet: ctx.internalGetReadSet() };\n  }\n\n  async query<T>(fn: (ctx: DbReader) => Promise<T>): Promise<T> {\n    const beginTs = await this.impl.getLatestSnapshotTimestamp();\n    const ctx = new DbReader(this.impl, beginTs);\n    return await fn(ctx);\n  }\n\n  /**\n   * Compute a query once at the latest snapshot, returning the result together\n   * with the snapshot `ts` and the tracked `readSet`. This is a plain one-shot\n   * evaluation — it registers NO live subscription; the `readSet`/`ts` are\n   * returned purely so the caller (e.g. the one-shot query cache) can store\n   * freshness metadata. Use this for cached one-shot query calls (WS `call`,\n   * HTTP RPC). `liveQuery` is the same computation under the subscription path's\n   * name and simply delegates here.\n   */\n  async queryInternal<T>(fn: (ctx: DbReader) => Promise<T>): Promise<LiveResult<T>> {\n    const beginTs = await this.impl.getLatestSnapshotTimestamp();\n    const ctx = new DbReader(this.impl, beginTs);\n    const data = await fn(ctx);\n\n    return {\n      ts: beginTs,\n      data,\n      readSet: ctx.internalGetReadSet(),\n    };\n  }\n\n  async liveQuery<T>(fn: (ctx: DbReader) => Promise<T>): Promise<LiveResult<T>> {\n    return this.queryInternal(fn);\n  }\n\n  // ── Mutation ───────────────────────────────────────────────────────\n\n  async mutation<T>(\n    fn: (ctx: DbWriter) => Promise<T>,\n    retryPolicy: RetryPolicy = occRetryPolicy,\n  ): Promise<MutationResult<T>> {\n    return await retryPolicy.execute(async (p) => {\n      let db: TxDatabase | undefined;\n      try {\n        // Step1: Get latest snapshot timestamp as beginTs\n        const beginTs = await this.impl.getLatestSnapshotTimestamp() + 1n;\n\n        const ctx = new DbWriter(this.impl, beginTs);\n        const result = await fn(ctx);\n\n        const readSet = ctx.internalGetReadSet();\n        const writeSet = ctx.internalGetWriteSet();\n        const commitTsLazy = new LazyCommitTsParam(undefined);\n\n        // Step2: Capture prevData + expectedCommitTs per write. prevData\n        // is consumed by the invalidator (range subs need it to detect\n        // result-set transitions). expectedCommitTs becomes the CAS fence\n        // for the apply step — preferring prior find()-captured ts so\n        // read-then-update patterns get beginTs-level isolation.\n        await this.impl.attachPrevDataToWriteSet(writeSet, readSet);\n\n        // Step3: Prepare quieries before transaction\n        const queries = await this.impl.prepareCommitWrites(\n          readSet,\n          writeSet,\n          commitTsLazy,\n        );\n\n        // Step4: Starts new transaction\n        db = await getDbclientRetryPolicy.execute(() => this.impl.getTransactionClient());\n        await db.begin();\n\n        // Step5: Get commitTs from DB sequence (bigger than all previous)\n        const commitTs = await db.getNextTimestamp();\n        commitTsLazy.value = commitTs;\n\n        // Step6: Apply + validate. CAS UPDATE/DELETE catches concurrent\n        // peer touches on the write set; the readSet is validated either\n        // per-row (fast path, no range reads) or via commit-log scan\n        // (slow path, when range reads are present so phantoms still\n        // need detection).\n        const commitResult = await traceDbCall(\n          \"commit\",\n          \"\",\n          this.impl.dbType,\n          () => db!.commitWrites(beginTs, queries, commitTs),\n        );\n\n        if (!commitResult.success) {\n          throw new OccConflictError(\"Commit failed\", { commitResult });\n        }\n\n        await db.updateLatestSnapshotTimestamp(commitTs);\n        await db.commit();\n\n        // Notify after successful commit\n        this.onAfterCommit?.(writeSet, commitTs);\n\n        return { result, writeSet, commitTs };\n      } catch (err) {\n        await db?.rollback();\n        throw err;\n      } finally {\n        db?.release();\n      }\n    });\n  }\n}\n\nexport const sleep = (ms: number) => new Promise<void>((res) => setTimeout(res, ms));\n"],"mappings":"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"}

package/dist/router-Bk0eLfmB.js

@@ -0,0 +1,285 @@
+//#region src/router/procedure.ts
+/**
+* A {@link HandlerLogger} that discards everything. Used as `ctx.log` for direct
+* internal-caller invocations (which run outside the server's request logger), so
+* handler code can ALWAYS call `ctx.log.info(...)` without a null check.
+*/
+const noopLogger = {
+	debug() {},
+	info() {},
+	warn() {},
+	error() {}
+};
+/**
+* No-op connection routing for query paths that genuinely ALWAYS run on the
+* primary — live subscription re-execution and mutation handlers. Spread into
+* the ctx so `ctx.usePrimaryConn()`/`useReplicaConn()` are always callable but
+* inert (there is only ever the primary connection to bind).
+*
+* For a nested `runQuery` that JOINS a parent transaction, use {@link parentConn}
+* instead — there the connection isn't necessarily the primary.
+*/
+const primaryOnlyConn = {
+	usePrimaryConn: () => {},
+	useReplicaConn: () => {}
+};
+/**
+* No-op connection routing for a nested `runQuery` that JOINS a parent
+* transaction (a `runQuery` called with a query/mutation `parentCtx`). The knobs
+* always use the PARENT's connection because the read connection is fixed to the
+* parent transaction's — which may be the PRIMARY or the REPLICA, depending on
+* how the parent query was routed.
+*
+* They MUST be inert: a nested query shares the parent's snapshot + readSet, so
+* calling `useConnection` here would either repoint the parent's connection
+* mid-flight (before its first read) or throw (after it) — either way corrupting
+* the parent transaction. A handler that needs to force primary therefore cannot
+* do so while nested under a replica-routed parent (it inherits the replica,
+* which is already safe w.r.t. the client's `minTs` floor); call it via an
+* action-parent `runQuery` instead, which opens a fresh routed read.
+*/
+const parentConn = {
+	usePrimaryConn: () => {},
+	useReplicaConn: () => {}
+};
+/**
+* Create a query builder with a pre-defined context type.
+* This allows you to define the context type once and have it inferred
+* automatically in all your query handlers.
+* 
+* @example
+* // Define your server context
+* interface ServerContext {
+*   auth: { userId: string };
+*   requestId: string;
+* }
+* 
+* // Create a typed query builder
+* const query = createQueryBuilder<ServerContext>();
+* 
+* // Use it - context type is automatically inferred!
+* const getUser = query({
+*   args: z.object({ id: z.string() }),
+*   handler: async (ctx, { id }) => {
+*     // ctx.db for database queries
+*     const user = await ctx.db.query(UsersSchema).find(id);
+*     // ctx.context for server context
+*     console.log(ctx.context.requestId);
+*     return user;
+*   }
+* });
+*/
+function createQueryBuilder() {
+	return function query(config) {
+		return {
+			_type: "procedure",
+			procedureType: "query",
+			inputSchema: config.args,
+			outputSchema: config.returns,
+			fn: config.handler,
+			internal: config.internal ?? false,
+			queryIdentity: config.queryIdentity
+		};
+	};
+}
+/**
+* Create a mutation builder with a pre-defined context type.
+* This allows you to define the context type once and have it inferred
+* automatically in all your mutation handlers.
+* 
+* @example
+* // Define your server context
+* interface ServerContext {
+*   auth: { userId: string };
+*   requestId: string;
+* }
+* 
+* // Create a typed mutation builder
+* const mutation = createMutationBuilder<ServerContext>();
+* 
+* // Use it - context type is automatically inferred!
+* const createUser = mutation({
+*   args: z.object({ name: z.string() }),
+*   handler: async (ctx, { name }) => {
+*     // ctx.db for mutations
+*     await ctx.db.insert(UsersSchema, id, { name });
+*     // ctx.context for server context
+*     console.log(ctx.context.requestId);
+*     return { success: true };
+*   }
+* });
+*/
+function createMutationBuilder() {
+	return function mutation(config) {
+		return {
+			_type: "procedure",
+			procedureType: "mutation",
+			inputSchema: config.args,
+			outputSchema: config.returns,
+			fn: config.handler,
+			internal: config.internal ?? false
+		};
+	};
+}
+/**
+* Create an action builder with a pre-defined context type.
+* Actions have access to the full SupaliveDb for both queries and mutations.
+*
+* @example
+* // Define your server context
+* interface ServerContext {
+*   auth: { userId: string };
+*   requestId: string;
+* }
+*
+* // Create a typed action builder
+* const action = createActionBuilder<ServerContext>();
+*
+* // Use it - context type is automatically inferred!
+* const processOrder = action({
+*   args: z.object({ orderId: z.string() }),
+*   handler: async (ctx, { orderId }) => {
+*     // ctx.db for full database access
+*     const order = await ctx.db.query(async (db) => {
+*       return db.query(OrdersSchema).find(orderId);
+*     });
+*     await ctx.db.mutation(async (db) => {
+*       await db.update(OrdersSchema, orderId, { status: "processed" });
+*     });
+*     // ctx.context for server context
+*     console.log(ctx.context.requestId);
+*     return { success: true };
+*   }
+* });
+*/
+function createActionBuilder() {
+	return function action(config) {
+		return {
+			_type: "procedure",
+			procedureType: "action",
+			inputSchema: config.args,
+			outputSchema: config.returns,
+			fn: config.handler,
+			internal: config.internal ?? false
+		};
+	};
+}
+/**
+* Create a job builder with a pre-defined context type. A job is a
+* server-only procedure invoked by the scheduler over HTTP — either on its
+* declared `cron` schedule or as a precise one-shot enqueued via the
+* server's job API. Jobs run like actions (full db, non-transactional) and
+* are always internal, so they are never reachable from a client.
+*
+* @example
+* const job = createJobBuilder<ServerContext>();
+*
+* export const cleanupOtps = job({
+*   cron: "0 * * * *", // hourly
+*   args: z.object({}),
+*   handler: async (ctx) => {
+*     await ctx.db.mutation(async (db) => { ... });
+*     return { ok: true };
+*   },
+* });
+*/
+function createJobBuilder() {
+	return function job(config) {
+		return {
+			_type: "procedure",
+			procedureType: "job",
+			inputSchema: config.args,
+			fn: config.handler,
+			internal: true,
+			cron: config.cron
+		};
+	};
+}
+//#endregion
+//#region src/router/router.ts
+/**
+* Create a router from procedure definitions.
+* Procedure names are inferred from the object keys.
+* 
+* @example
+* const appRouter = router({
+*   procedures: {
+*     getUser,
+*     createUser,
+*     internalGetAll,
+*   },
+* });
+* 
+* export type AppRouter = typeof appRouter;
+*/
+function router(config) {
+	const registry = getContextRegistry(config.contextName ?? "default");
+	for (const [name, proc] of Object.entries(config.procedures)) registry.registerProcedure(name, proc);
+	return {
+		_type: "router",
+		procedures: config.procedures,
+		contextName: config.contextName ?? "default"
+	};
+}
+const contextRegistry = /* @__PURE__ */ new Map();
+function getContextRegistry(inContext) {
+	let registry = contextRegistry.get(inContext);
+	if (!registry) {
+		registry = new ContextRegistry();
+		contextRegistry.set(inContext, registry);
+	}
+	return registry;
+}
+var ContextRegistry = class {
+	procedureRegistry = /* @__PURE__ */ new Map();
+	internalProcedureNames = /* @__PURE__ */ new Set();
+	registerProcedure(name, proc) {
+		if (this.procedureRegistry.has(name)) throw new Error(`[router] Procedure "${name}" is already registered. Each procedure name must be unique across the application.`);
+		if (proc.internal) this.markInternalProcedure(name);
+		const queryIdentity = proc.procedureType === "query" ? proc.queryIdentity : void 0;
+		const cron = proc.procedureType === "job" ? proc.cron : void 0;
+		this.procedureRegistry.set(name, {
+			name,
+			type: proc.procedureType,
+			internal: proc.internal,
+			inputSchema: proc.inputSchema,
+			fn: proc.fn,
+			queryIdentity,
+			cron
+		});
+	}
+	/** Get a registered procedure by name (runtime lookup) */
+	getProcedure(name) {
+		return this.procedureRegistry.get(name);
+	}
+	/** Get all registered procedure names */
+	getProcedureNames() {
+		return [...this.procedureRegistry.keys()];
+	}
+	/** Get all registered procedures */
+	getAllProcedures() {
+		return new Map(this.procedureRegistry);
+	}
+	/** Get all registered job procedures (server-only, scheduler-triggered). */
+	getJobProcedures() {
+		return [...this.procedureRegistry.values()].filter((p) => p.type === "job");
+	}
+	/** Clear the registry (for testing only) */
+	clearRegistry() {
+		this.procedureRegistry.clear();
+		this.clearInternalProcedures();
+	}
+	markInternalProcedure(name) {
+		this.internalProcedureNames.add(name);
+	}
+	isInternalProcedure(name) {
+		return this.internalProcedureNames.has(name);
+	}
+	clearInternalProcedures() {
+		this.internalProcedureNames.clear();
+	}
+};
+//#endregion
+export { createJobBuilder as a, noopLogger as c, createActionBuilder as i, parentConn as l, getContextRegistry as n, createMutationBuilder as o, router as r, createQueryBuilder as s, ContextRegistry as t, primaryOnlyConn as u };
+
+//# sourceMappingURL=router-Bk0eLfmB.js.map