@gaganref/confect-test 10.3.1-fork.90 → 10.3.1-fork.92

package/dist/internal/Execution.js

@@ -1,7 +1,8 @@
 import { own } from "./Globals.js";
 import { install } from "./Clock.js";
-import { createFunctionHandle, createTestJwt, deserializeConvexErrorData, evaluateValue, hasPendingValues, parseArgs, parseFunctionHandle, resolveCommittedValues, simpleHash, tableNameFromId, validateFunctionArgs, validateReturnValue } from "./KernelValues.js";
+import { createFunctionHandle, createTestJwt, deserializeConvexErrorData, evaluateValue, hasPendingValues, isSimpleObject, parseArgs, parseFunctionHandle, resolveCommittedValues, simpleHash, tableNameFromId, validateFunctionArgs, validateReturnValue } from "./KernelValues.js";
 import { apply, conflict, empty, wallClock } from "./Kernel.js";
+import { defaults, everything, examined, fromBudget, point } from "./Metering.js";
 import { KernelAttempt } from "./Attempt.js";
 import { bind, current as current$1, fresh, unbound } from "./Invocation.js";
 import { ClosedAttempt, CommitTsNotIncreasing, DrainBudgetExceeded, OptimisticConcurrencyControlFailure, RegisteredAfterOpen, StaleAttempt, UnknownStandingSource, requiresBinary, rowPending } from "./KernelRefusal.js";
@@ -9,7 +10,7 @@ import { exportSchema, paginate, stream, validateDocument } from "./KernelQuery.
 import { functions, pending, row, stateOf, table } from "./Scheduling.js";
 import { actionGeneric, getFunctionAddress, mutationGeneric, queryGeneric } from "convex/server";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { convexToJson, jsonToConvex } from "convex/values";
+import { CommitTsPlaceholder, compareValues, convexToJson, jsonToConvex } from "convex/values";
 //#region src/internal/Execution.ts
 const ROOT = "";
 const TYPICAL_CONVEX_ID_LENGTH = 32;
@@ -82,12 +83,15 @@ const enter = (execution, run) => {
 const kernelBrand = Symbol.for("@confect/test/Kernel");
 /**
 * The time `Date` answers inside a kernel invocation: a query's or mutation's
-* start, or the clock as it runs in an action. Outside one, none.
+* start, or the clock as it runs in an action. Outside one, none. A query or
+* mutation that reads it takes a dependency on that time.
 */
 const pinnedTime = () => {
 	const execution = executions.getStore();
 	if (execution === void 0) return void 0;
-	return execution.udfType === "action" ? execution.world.now() : execution.startTime;
+	if (execution.udfType === "action") return execution.world.now();
+	execution.attempt?.observeTime(execution.startTime);
+	return execution.startTime;
 };
 /**
 * How many jobs one drain or advance runs before it gives up, as convex-test's
@@ -360,6 +364,46 @@ var World = class {
 		return Array.from(this.holding.values(), (held) => held.view);
 	}
 	/**
+	* Run a query at the latest commit as a subscription runs it, under `caller`,
+	* and return its answer with every dependency it took. `time` pins the time
+	* it reads, the kernel's time now by default. `journal` ends its paginated
+	* read where an earlier run's ended.
+	*/
+	subscribed(caller, reference, args, pinned) {
+		return this.open().then(() => {
+			const functionPath = pathOfReference(reference, ROOT);
+			const resolved = this.resolve(functionPath, "query");
+			validateFunctionArgs(resolved.args, args ?? {}, functionPath, false);
+			const top = {
+				attempt: new KernelAttempt(this.state),
+				pagination: {
+					calls: 0,
+					journal: pinned.journal,
+					end: null
+				},
+				startTime: pinned.time
+			};
+			const run = (outcome) => ({
+				outcome,
+				snapshot: top.attempt.snapshot.version,
+				reads: top.attempt.reads,
+				observedIdentity: top.attempt.observedIdentity,
+				time: top.attempt.observedTime,
+				journal: pinned.journal ?? top.pagination.end
+			});
+			return this.runQuery(functionPath, resolved, args, {
+				caller,
+				request: newRequest(caller)
+			}, false, top).then((value) => run({
+				_tag: "returned",
+				value
+			}), (error) => run({
+				_tag: "failed",
+				error
+			}));
+		});
+	}
+	/**
 	* The committed pending jobs, earliest deadline first.
 	*/
 	jobs() {
@@ -490,7 +534,12 @@ var World = class {
 		this.component(target.componentPath);
 		const jobArgs = jsonToConvex(args.args);
 		if (hasPendingValues(jobArgs)) throw new Error(`Invalid arguments for "${target.udfPath}": a scheduled function cannot take an unresolved placeholder value.`);
+		refuse(attempt.meter.schedule(jobArgs, execution.limits));
+		const jobsIndex = indexKey(execution.componentPath, table, "by_id");
+		const parentJob = execution.request.scheduledFunctionId;
+		if (parentJob !== null) refuse(attempt.meter.readInterval(jobsIndex, point([parentJob]), execution.limits));
 		const id = this.generateId(table);
+		attempt.meter.deriveInterval(jobsIndex, point([id]));
 		attempt.write(execution.componentPath, id, row(id, this.creationTime(execution.startTime), target.udfPath, jobArgs, args.ts * 1e3));
 		this.targets.set(id, {
 			functionPath: target,
@@ -505,10 +554,10 @@ var World = class {
 	/**
 	* Cancel a job that has not finished. A finished job stays as it ended.
 	*/
-	cancelJob(attempt, componentPath, id) {
+	cancelJob(attempt, execution, id) {
+		const { componentPath } = execution;
 		validateId(table, id);
-		attempt.readDocument(componentPath, id);
-		const doc = attempt.get(componentPath, id);
+		const doc = this.readById(attempt, execution, id);
 		if (doc === null) throw new Error(`Patch on non-existent document with ID "${id}"`);
 		const { kind } = stateOf(doc);
 		if (kind === "pending" || kind === "inProgress") attempt.write(componentPath, id, {
@@ -534,8 +583,10 @@ var World = class {
 		validateFunctionArgs(resolved.args, args ?? {}, functionPath, false);
 		return this.runAction(functionPath, resolved, args, from);
 	}
-	execution(functionPath, udfType, attempt, from, pagination) {
+	execution(functionPath, udfType, attempt, from, pagination, startTime) {
 		const identity = functionPath.componentPath !== ROOT ? null : from.parent !== void 0 ? from.parent.identity : from.caller.identity;
+		const inherited = attempt === void 0 || from.parent?.attempt === void 0 ? defaults : from.parent.limits;
+		const limits = attempt === void 0 || from.budget === void 0 ? inherited : fromBudget(from.budget, attempt.meter.used(), inherited);
 		return {
 			world: this,
 			componentPath: functionPath.componentPath,
@@ -544,16 +595,21 @@ var World = class {
 			attempt,
 			identity,
 			request: from.request,
-			startTime: from.parent !== void 0 && from.parent.udfType !== "action" ? from.parent.startTime : this.now(),
+			startTime: startTime ?? (from.parent !== void 0 && from.parent.udfType !== "action" ? from.parent.startTime : this.now()),
 			pagination,
-			turn: new Turn()
+			turn: new Turn(),
+			limits
 		};
 	}
-	runQuery(functionPath, resolved, args, from, snapshotOnly = false) {
+	runQuery(functionPath, resolved, args, from, snapshotOnly = false, top) {
 		const parentAttempt = from.parent?.attempt;
 		const isNested = parentAttempt !== void 0;
-		const attempt = parentAttempt === void 0 ? new KernelAttempt(this.state) : snapshotOnly ? new KernelAttempt(parentAttempt.snapshot) : parentAttempt;
-		const execution = this.execution(functionPath, "query", attempt, from, isNested && from.parent?.pagination || { calls: 0 });
+		const attempt = top?.attempt ?? (parentAttempt === void 0 ? new KernelAttempt(this.state) : snapshotOnly ? parentAttempt.staleSnapshot() : parentAttempt);
+		const execution = this.execution(functionPath, "query", attempt, from, top?.pagination ?? (isNested && from.parent?.pagination || {
+			calls: 0,
+			journal: null,
+			end: null
+		}), top?.startTime);
 		const q = queryGeneric({ handler: (ctx, a) => resolved.handler({
 			...ctx,
 			auth: queryAuth(execution)
@@ -724,16 +780,50 @@ var World = class {
 	}
 	view(execution) {
 		const attempt = transaction(execution);
+		const { componentPath, limits } = execution;
 		return {
-			schema: this.schema(execution.componentPath),
-			scan: (tableName) => attempt.scan(execution.componentPath, tableName),
-			read: (interval, after) => attempt.readInterval({
-				...interval,
-				componentPath: execution.componentPath,
-				after
-			})
+			schema: this.schema(componentPath),
+			scan: (tableName) => attempt.scan(componentPath, tableName),
+			read: ({ index, ...interval }, after) => {
+				const advance = attempt.readInterval({
+					...interval,
+					componentPath,
+					after
+				});
+				return (through) => {
+					advance(through);
+					const examined$1 = examined(interval.range, interval.order, after, through);
+					if (examined$1 !== null) refuse(attempt.meter.readInterval(indexKey(componentPath, interval.table, index), examined$1, limits));
+				};
+			},
+			examine: (table, doc) => refuse(attempt.meter.readDocument(doc, isSystemTable(table), limits))
 		};
 	}
+	/**
+	* Read one document by ID, as the binary's `get_inner` does for a get and for
+	* the document a patch, replace, delete or cancel changes: it reads the ID's
+	* interval of the table's `by_id` index, then charges the document if there
+	* is one (`crates/database/src/transaction.rs:1188-1250`).
+	*/
+	readById(attempt, execution, id) {
+		const { componentPath, limits } = execution;
+		const table = tableNameFromId(id);
+		attempt.readDocument(componentPath, id);
+		refuse(attempt.meter.readInterval(indexKey(componentPath, table, "by_id"), point([id]), limits));
+		const doc = attempt.get(componentPath, id);
+		if (doc !== null) refuse(attempt.meter.readDocument(doc, isSystemTable(table), limits));
+		return doc;
+	}
+	/**
+	* Stage a write to a user table, counted against the execution's limits
+	* first. A write over a limit is not staged (`Writes::update`,
+	* `crates/database/src/writes.rs:241-310`).
+	*/
+	stage(execution, id, doc) {
+		const attempt = transaction(execution);
+		refuse(attempt.meter.write(doc, execution.limits));
+		attempt.write(execution.componentPath, id, doc);
+	}
 	generateId(table) {
 		return String(this.nextDocId++).padStart(TYPICAL_CONVEX_ID_LENGTH - table.length, "0") + table;
 	}
@@ -803,7 +893,12 @@ var World = class {
 					pagination.calls += 1;
 					if (pagination.calls > 1) throw new Error("Only a single paginated query (`.paginate()`) is allowed per query, including nested query calls and component calls. This is a Convex limit: https://docs.convex.dev/database/pagination");
 				}
-				return JSON.stringify(convexToJson(paginate(this.view(execution), args)));
+				const page = paginate(this.view(execution), {
+					...args,
+					endCursor: args.endCursor ?? pagination?.journal ?? null
+				});
+				if (pagination) pagination.end = page.continueCursor;
+				return JSON.stringify(convexToJson(page));
 			}
 			case "1.0/insert": return JSON.stringify({ _id: this.insert(execution, args.table, jsonToConvex(args.value)) });
 			case "1.0/shallowMerge":
@@ -817,6 +912,7 @@ var World = class {
 				return JSON.stringify({});
 			case "1.0/count": {
 				const attempt = transaction(execution);
+				refuse(attempt.meter.readInterval(indexKey(execution.componentPath, args.table, "by_id"), everything, execution.limits));
 				attempt.readInterval({
 					kind: "interval",
 					componentPath: execution.componentPath,
@@ -851,10 +947,11 @@ var World = class {
 				return (op === "1.0/actions/query" ? this.queryAt(functionPath, args.args, from) : op === "1.0/actions/mutation" ? this.mutationAt(functionPath, args.args, from) : this.actionAt(functionPath, args.args, from)).then((value) => JSON.stringify(convexToJson(value)));
 			}
 			case "1.0/runUdf": {
-				const { udfType, args: udfArgs } = args;
+				const { udfType, args: udfArgs, transactionLimits } = args;
 				const from = {
 					request: execution.request,
-					parent: execution
+					parent: execution,
+					budget: budgetOf(transactionLimits)
 				};
 				const functionPath = functionPathOf(args, execution.componentPath);
 				const value = jsonToConvex(udfArgs);
@@ -869,15 +966,17 @@ var World = class {
 			case "1.0/schedule": return JSON.stringify(convexToJson(this.scheduleJob(transaction(execution), execution, args)));
 			case "1.0/actions/schedule": return JSON.stringify(convexToJson(this.commitNow((attempt) => this.scheduleJob(attempt, execution, args))));
 			case "1.0/cancel_job":
-				this.cancelJob(transaction(execution), execution.componentPath, args.id);
+				this.cancelJob(transaction(execution), execution, args.id);
 				return JSON.stringify({});
 			case "1.0/actions/cancel_job":
-				this.commitNow((attempt) => this.cancelJob(attempt, execution.componentPath, args.id));
+				this.commitNow((attempt) => this.cancelJob(attempt, execution, args.id));
 				return JSON.stringify({});
 			case "1.0/storageDelete":
 			case "1.0/storageGetUrl":
 			case "1.0/storageGenerateUploadUrl": throw rowPending("storage", 6);
-			case "1.0/getTransactionMetrics": throw rowPending("transaction limits", 6);
+			case "1.0/getTransactionMetrics":
+				if (execution.attempt === void 0) throw new Error(`Unknown async operation ${op}`);
+				return JSON.stringify(execution.attempt.meter.metrics(execution.limits));
 			case "1.0/actions/vectorSearch": throw requiresBinary("vectorSearch");
 			default: throw new Error(`The test kernel does not support async syscall: "${op}"`);
 		}
@@ -887,15 +986,14 @@ var World = class {
 	}
 	get(execution, tableName, id) {
 		validateId(tableName, id);
-		const attempt = transaction(execution);
-		attempt.readDocument(execution.componentPath, id);
-		return attempt.get(execution.componentPath, id);
+		return this.readById(transaction(execution), execution, id);
 	}
 	insert(execution, table, value) {
 		const attempt = transaction(execution);
 		validateDocument(this.schema(execution.componentPath), table, value);
 		const _id = this.generateId(table);
-		attempt.write(execution.componentPath, _id, {
+		attempt.meter.deriveInterval(indexKey(execution.componentPath, table, "by_id"), point([_id]));
+		this.stage(execution, _id, {
 			...value,
 			_id,
 			_creationTime: this.creationTime(execution.startTime)
@@ -914,9 +1012,7 @@ var World = class {
 	existing(execution, tableName, id, write, value) {
 		validateId(tableName, id);
 		if (value !== void 0 && typeof value !== "object") throw new Error(`Invalid argument \`value\` in \`db.${write}\`, expected object but got '${typeof value}': ${value}`);
-		const attempt = transaction(execution);
-		attempt.readDocument(execution.componentPath, id);
-		const document = attempt.get(execution.componentPath, id);
+		const document = this.readById(transaction(execution), execution, id);
 		if (document === null) throw new Error(write === "delete" ? "Delete on non-existent doc" : `${write === "patch" ? "Patch" : "Replace"} on non-existent document with ID "${id}"`);
 		return document;
 	}
@@ -934,27 +1030,87 @@ var World = class {
 			...fields,
 			...this.fields(document, value)
 		};
-		validateDocument(this.schema(execution.componentPath), tableNameFromId(_id), merged);
-		transaction(execution).write(execution.componentPath, _id, {
+		const next = {
 			_id,
 			_creationTime,
 			...merged
-		});
+		};
+		if (sameDocument(document, next)) return;
+		validateDocument(this.schema(execution.componentPath), tableNameFromId(_id), merged);
+		this.stage(execution, _id, next);
 	}
 	replace(execution, tableName, id, value) {
 		const document = this.existing(execution, tableName, id, "replace", value);
 		const fields = this.fields(document, value);
-		validateDocument(this.schema(execution.componentPath), tableNameFromId(document._id), fields);
-		transaction(execution).write(execution.componentPath, document._id, {
+		const next = {
 			...fields,
 			_id: document._id,
 			_creationTime: document._creationTime
-		});
+		};
+		if (sameDocument(document, next)) return;
+		validateDocument(this.schema(execution.componentPath), tableNameFromId(document._id), fields);
+		this.stage(execution, document._id, next);
 	}
 	remove(execution, tableName, id) {
 		const document = this.existing(execution, tableName, id, "delete", void 0);
-		transaction(execution).write(execution.componentPath, document._id, null);
+		this.stage(execution, document._id, null);
+	}
+};
+const refuse = (error) => {
+	if (error !== void 0) throw error;
+};
+/**
+* One index of one table in one component, as the binary keys a read set.
+*/
+const indexKey = (componentPath, table, index) => `${componentPath}\u0000${table}\u0000${index}`;
+const isSystemTable = (table) => table.startsWith("_");
+const isFieldMap = (value) => typeof value === "object" && value !== null && isSimpleObject(value);
+/**
+* Whether two stored values are the same value, an unresolved commit timestamp
+* included. The binary compares pending values structurally, so a pending
+* timestamp equals only another pending timestamp, at any depth (`PendingValue`
+* derives `PartialEq`, `crates/value/src/pending.rs:56-75`, as
+* `PendingDocument` does, `crates/common/src/document.rs:624-632`). Concrete
+* values compare by `ConvexValue`'s total order
+* (`crates/value/src/sorting.rs:468-472`), which `compareValues` follows.
+* `compareValues` alone ranks a pending timestamp as the largest int64, so it
+* cannot tell the two apart. An object field set to `undefined` is absent.
+*/
+const sameValue = (a, b) => {
+	const aPending = a instanceof CommitTsPlaceholder;
+	const bPending = b instanceof CommitTsPlaceholder;
+	if (aPending || bPending) return aPending && bPending;
+	if (Array.isArray(a) || Array.isArray(b)) return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((value, i) => sameValue(value, b[i]));
+	if (isFieldMap(a) || isFieldMap(b)) {
+		if (!isFieldMap(a) || !isFieldMap(b)) return false;
+		const fields = (value) => Object.entries(value).filter(([, field]) => field !== void 0);
+		const aFields = fields(a);
+		const bFields = new Map(fields(b));
+		return aFields.length === bFields.size && aFields.every(([key, field]) => bFields.has(key) && sameValue(field, bFields.get(key)));
+	}
+	return compareValues(a, b) === 0;
+};
+/**
+* Whether a patch or replace leaves a document as it was. The binary then
+* writes nothing (`patch_inner` and `replace_inner`,
+* `crates/database/src/transaction.rs:713-790`).
+*/
+const sameDocument = (before, after) => sameValue(before, after);
+/**
+* A nested call's `transactionLimits`. The binary reads each field as an
+* unsigned integer and ignores fields it does not know (`TransactionLimits`,
+* `crates/database/src/execution_size.rs:62-95`).
+*/
+const budgetOf = (limits) => {
+	if (limits === void 0 || limits === null) return void 0;
+	const budget = {};
+	for (const metric of Object.keys(defaults)) {
+		const value = limits[metric];
+		if (value === void 0) continue;
+		if (typeof value !== "number" || !Number.isInteger(value) || value < 0) throw new Error(`Invalid arguments for \`runUdf\`: transactionLimits.${metric} must be a non-negative integer, got ${JSON.stringify(value)}`);
+		budget[metric] = value;
 	}
+	return budget;
 };
 const closed = (execution, operation) => new ClosedAttempt({
 	operation,
@@ -964,7 +1120,10 @@ const transaction = (execution) => {
 	if (execution.attempt === void 0) throw new Error("The database is only available in queries and mutations. An action reads and writes through `ctx.runQuery` and `ctx.runMutation`.");
 	return execution.attempt;
 };
-const queryAuth = (execution) => ({ getUserIdentity: () => Promise.resolve(execution.identity) });
+const queryAuth = (execution) => ({ getUserIdentity: () => {
+	execution.attempt?.observeIdentity();
+	return Promise.resolve(execution.identity);
+} });
 const mutationAuth = (execution) => ({
 	...queryAuth(execution),
 	signJwt: () => Promise.reject(rowPending("JWT signing", 6))