foldkit-remote 0.20.0 → 0.21.0

package/dist/{src-BDqn7Ocr.mjs → src-lVP_7bf4.mjs}

@@ -1,7 +1,7 @@
 import { Context, Data, Deferred, Duration, Effect, Layer, Match, Option, Predicate, Record, Request, RequestResolver, Result, Schema, SchemaAST, SchemaGetter, Stream } from "effect";
 import { KeyValueStore } from "effect/persistence";
 import * as Domain from "foldkit-entity";
-import { Entity, Expr, Operators, Query, QueryEvaluateError, ReadFilter, SchemaShape, SelectionTypeId, Write, compareRows, dependenciesOf, evaluate } from "foldkit-entity";
+import { Entity, Expr, Operators, Query, QueryEvaluateError, ReadFilter, SchemaShape, SelectionTypeId, Write, compareRows, dependenciesOf, evaluateEach } from "foldkit-entity";
 import { mapMessage } from "foldkit/command";
 import { defineMessageUnion } from "foldkit/message";
 import * as Subscription from "foldkit/subscription";
@@ -556,16 +556,17 @@ const patchOfWrite = (bound) => ({
 /**
 * What a declared write shows before the server answers: an update's or an
 * insert's row as a patch (an update's only for the keys named, when some
-* are), and an update's increments as amounts over the value the store holds. A delete shows nothing, since no operation removes a row from every
-* list it is in; its answer does.
+* are), and an update's increments and computed fields, worked out over the
+* row the store holds when it is read. A delete shows nothing, since no
+* operation removes a row from every list it is in; its answer does.
 */
 const optimisticOfWrite = (write, input, keys) => Match.value(write).pipe(Match.tagsExhaustive({
 	Update: () => {
 		const bound = Write.bind(write, input, keys);
-		const patch = patchOfWrite(bound);
-		return [Object.keys(bound.increments).length === 0 ? patch : {
-			...patch,
-			adds: bound.increments
+		return [{
+			...patchOfWrite(bound),
+			...Object.keys(bound.increments).length === 0 ? {} : { adds: bound.increments },
+			...Object.keys(bound.assignments).length === 0 ? {} : { computes: bound.assignments }
 		}];
 	},
 	Insert: () => {
@@ -1392,7 +1393,10 @@ const dedupeConnection = (segments) => {
 /** Adds a page to the connection, joining contiguous or overlapping segments. */
 const merge = (current, page) => {
 	const incoming = normalize(page);
-	if (incoming.edges.length === 0) return current;
+	if (incoming.edges.length === 0) return incoming.start._tag === "Terminal" && incoming.end._tag === "Terminal" && current.segments.length === 0 ? {
+		...current,
+		segments: [incoming]
+	} : current;
 	const segments = [...current.segments.map(normalize), incoming];
 	let joined = true;
 	while (joined) {
@@ -1907,9 +1911,11 @@ const matchingEncoded = (store, descriptor, encoded, options = {}) => {
 			__key: key
 		});
 	}
+	const judged = evaluateEach(body, encoded, rows, { operators: options.operators });
+	const keyOf = (row) => row.__key;
 	return {
-		matched: evaluate(body, encoded, rows, { operators: options.operators }).map((row) => row.__key),
-		skipped
+		matched: judged.matched.map(keyOf),
+		skipped: [...skipped, ...judged.refused.map(keyOf)]
 	};
 };
 /**
@@ -2190,7 +2196,7 @@ const removeOverlay = (optimistic, id) => {
 * entity only a request holds (a temporary id) is not the server's to age, and
 * is dated `Infinity`, so freshness never plans or times it.
 */
-const visibleStore = (base, optimistic) => writeEntities(base, resolvedPatches(base, optimistic).map((patch) => {
+const visibleStore = (base, optimistic, operators = Operators.kernel) => writeEntities(base, resolvedPatches(base, optimistic, operators).map((patch) => {
 	const key = entityKey(patch.entity, patch.id);
 	const under = base[key];
 	return {
@@ -2200,32 +2206,56 @@ const visibleStore = (base, optimistic) => writeEntities(base, resolvedPatches(b
 	};
 }));
 /**
-* Every pending patch in order, each amount added to the value under it: the
-* store's, or an earlier layer's. A prediction, so only over a number the
-* client holds: a field it has not read, or holds as anything else, keeps
-* what it shows until the server answers with the sum.
+* Every pending patch in order, each amount added and each computed field
+* worked out over the row under it (the store's, with earlier layers over
+* it) by `Write.apply`, with the client's table (the kernel's when not
+* given). A prediction, so only over
+* what the client holds: a field it has not read, an amount over anything
+* but a number, or a computation by an operator its table lacks keeps what
+* it shows until the server answers.
 */
-const resolvedPatches = (base, optimistic) => {
+const resolvedPatches = (base, optimistic, operators = Operators.kernel) => {
 	const shown = /* @__PURE__ */ new Map();
-	return optimistic.layers.flatMap((layer) => layer.patches.map(({ adds, ...patch }) => {
+	const unsure = /* @__PURE__ */ new Map();
+	return optimistic.layers.flatMap((layer) => layer.patches.map(({ adds, computes, ...patch }) => {
 		const key = entityKey(patch.entity, patch.id);
 		const earlier = shown.get(key) ?? {};
+		const unknown = new Set([...unsure.get(key) ?? []].filter((field) => !Object.hasOwn(patch.values, field)));
 		const values = { ...patch.values };
-		const under = base[key];
-		const valueUnder = (field) => Object.hasOwn(earlier, field) ? Option.some(earlier[field]) : Option.fromUndefinedOr(under?.values[field]);
-		for (const [field, amount] of Object.entries(adds ?? {})) Option.map(Option.filter(valueUnder(field), Predicate.isNumber), (current) => {
-			values[field] = current + amount;
-		});
+		const row = Object.fromEntries(Object.entries({
+			...base[key]?.values,
+			...earlier
+		}).filter(([field]) => !unknown.has(field)));
+		const moved = {
+			values: {},
+			increments: adds ?? {},
+			assignments: computes ?? {}
+		};
+		const predicted = predicting(() => Write.apply(row, moved, { operators }));
+		for (const field of [...Object.keys(moved.increments), ...Object.keys(moved.assignments)]) if (predicted !== void 0 && !predicted.unknown.includes(field)) {
+			values[field] = predicted.row[field];
+			unknown.delete(field);
+		} else unknown.add(field);
 		shown.set(key, {
 			...earlier,
 			...values
 		});
+		unsure.set(key, unknown);
 		return {
 			...patch,
 			values
 		};
 	}));
 };
+/** A prediction, or none where an operator refuses the row it is given: the server will answer. */
+const predicting = (predict) => {
+	try {
+		return predict();
+	} catch (error) {
+		if (error instanceof QueryEvaluateError) return void 0;
+		throw error;
+	}
+};
 /**
 * A fresh page is newer than any settled overlay it covers: an edge the page
 * carries no longer needs an insert overlay, and a `remove` overlay hiding it
@@ -4356,8 +4386,8 @@ const placeableReadContract = (contract, body, operators) => {
 		}
 	};
 };
-const metaOf = (remote, asked) => {
-	const visible = visibleStoreOf(remote.entities, remote.optimistic);
+const metaOf = (remote, asked, operators) => {
+	const visible = visibleStoreOf(remote.entities, remote.optimistic, operators);
 	let updatedAt;
 	let stale = false;
 	let loading = false;
@@ -4407,7 +4437,7 @@ const metaOf = (remote, asked) => {
 */
 const storeOf = (bound, model) => {
 	const remote = bound.store.get(model);
-	return visibleStoreOf(remote.entities, remote.optimistic);
+	return visibleStoreOf(remote.entities, remote.optimistic, bound.operators);
 };
 /**
 * The Model as it would be with nothing optimistic pending. Every read reaches
@@ -4426,15 +4456,20 @@ const confirmed = (bound, projection) => ({
 	read: (root) => projection.read(withoutOptimistic(bound, root))
 });
 const visibleStores = /* @__PURE__ */ new WeakMap();
-const visibleStoreOf = (entities, optimistic) => {
-	let byStore = visibleStores.get(optimistic.layers);
+const visibleStoreOf = (entities, optimistic, operators) => {
+	let byLayers = visibleStores.get(operators);
+	if (byLayers === void 0) {
+		byLayers = /* @__PURE__ */ new WeakMap();
+		visibleStores.set(operators, byLayers);
+	}
+	let byStore = byLayers.get(optimistic.layers);
 	if (byStore === void 0) {
 		byStore = /* @__PURE__ */ new WeakMap();
-		visibleStores.set(optimistic.layers, byStore);
+		byLayers.set(optimistic.layers, byStore);
 	}
 	let visible = byStore.get(entities);
 	if (visible === void 0) {
-		visible = visibleStore(entities, optimistic);
+		visible = visibleStore(entities, optimistic, operators);
 		byStore.set(entities, visible);
 	}
 	return visible;
@@ -4543,9 +4578,10 @@ const defineRemote = (config) => {
 	};
 };
 /** Binds a Remote domain to its store's location in the application Model. */
-const bindRemote = (definition, store) => ({
+const bindRemote = (definition, store, operators) => ({
 	definition,
 	store,
+	operators,
 	contract: {
 		kind: "remote",
 		name: store.dependency.join(".") || "remote",
@@ -4651,7 +4687,7 @@ const missingRows = (known, window, size) => {
 		before: to.cursor
 	};
 };
-const planAsked = (remote, asked, options) => {
+const planAsked = (remote, asked, options, operators) => {
 	const queries = [];
 	const items = [];
 	const connections = Requirement.mergeConnections(asked.connections);
@@ -4669,7 +4705,7 @@ const planAsked = (remote, asked, options) => {
 		const edges = visibleItems(known, connection.identity, remote.optimistic.overlays, remote.entities);
 		items.push(...itemsOf(edges.map((edge) => edge.ref), connection.select));
 	}
-	const visible = visibleStoreOf(remote.entities, remote.optimistic);
+	const visible = visibleStoreOf(remote.entities, remote.optimistic, operators);
 	const read = [...asked.requirements, ...items];
 	const planned = plan(visible, read, options);
 	return {
@@ -4872,7 +4908,7 @@ const observeEntry = (bound, askedOf, toMessage, options) => {
 			let byAsked = planned.get(remote);
 			const known = byAsked?.get(askedKey);
 			if (known !== void 0 && at < known.until) return known.dependencies;
-			const plan = planAsked(remote, asked, RemotePolicy.toPlan(policy, at));
+			const plan = planAsked(remote, asked, RemotePolicy.toPlan(policy, at), bound.operators);
 			const dependencies = {
 				refresh: refreshedAt(remote.refresh, plan.requirements, plan.queries.map((query) => query.identity)),
 				requirements: plan.requirements,
@@ -5116,9 +5152,11 @@ const Remote = {
 	/**
 	* Binds a Remote domain to its store's location in the application Model. The
 	* registered entity names are carried on the returned value, so `Remote.select`
-	* rejects a selection for an entity this domain never declared.
+	* rejects a selection for an entity this domain never declared. `operators`
+	* is the client's table, which a pending computed assignment is predicted by
+	* (`Operators.kernel` when not given), as `Remote.make`'s is.
 	*/
-	at: bindRemote,
+	at: (definition, store, options = {}) => bindRemote(definition, store, options.operators ?? Operators.kernel),
 	/**
 	* The resume part for this domain, for `foldkit-ssr`'s `SSR.plan({ parts })`:
 	* a server render sends what the plan's active Surfaces read from the store,
@@ -5203,18 +5241,18 @@ const Remote = {
 	* connection marked stale; `loading` is any of them in flight. Optimistic
 	* previews do not date: showing only one reads `updatedAt: undefined`.
 	*/
-	meta: (bound, model, projection) => metaOf(bound.store.get(model), askedOf(projection)),
+	meta: (bound, model, projection) => metaOf(bound.store.get(model), askedOf(projection), bound.operators),
 	/**
 	* The pure plan for a projection against a Model: the requirements its
 	* remote store does not satisfy, under `options` (freshness, force). A
 	* Surface's projection is `surface.projection(params)`.
 	*/
-	plan: (bound, model, projection, options) => planAsked(bound.store.get(model), askedOf(projection), options ?? {}).requirements,
+	plan: (bound, model, projection, options) => planAsked(bound.store.get(model), askedOf(projection), options ?? {}, bound.operators).requirements,
 	/**
 	* The queries a projection needs run before its connections read: those the
 	* Model does not hold, or holds stale (every one under `force`).
 	*/
-	planQueries: (bound, model, projection, options) => planAsked(bound.store.get(model), askedOf(projection), options ?? {}).queries.flatMap((query) => query.ref === void 0 ? [] : [query.ref]),
+	planQueries: (bound, model, projection, options) => planAsked(bound.store.get(model), askedOf(projection), options ?? {}, bound.operators).queries.flatMap((query) => query.ref === void 0 ? [] : [query.ref]),
 	/**
 	* The store reads see: the base store under the pending optimistic layers.
 	* One store is shared by every read and plan of a Model whose remote state
@@ -5276,7 +5314,7 @@ const Remote = {
 			const known = remote.connections[connection.identity];
 			return known === void 0 ? [] : itemsOf(visibleItems(known, connection.identity, remote.optimistic.overlays, remote.entities).map((edge) => edge.ref), connection.select);
 		});
-		const requirements = plan(visibleStoreOf(remote.entities, remote.optimistic), [...asked.requirements, ...items], { force: true });
+		const requirements = plan(visibleStoreOf(remote.entities, remote.optimistic, bound.operators), [...asked.requirements, ...items], { force: true });
 		const invalidated = connections.filter((connection) => remote.connections[connection.identity] !== void 0 || connection.identity in remote.failures.connections).map((connection) => connection.identity);
 		const marked = [...requirements.length === 0 ? [] : [{
 			_tag: "RefreshStarted",
@@ -5469,7 +5507,7 @@ const failedReadWords = (error) => {
 /** The bound domain: the descriptor, the binding, and the operations over them. */
 const bindDomain = (definition, store, options = {}) => {
 	const operators = options.operators ?? Operators.kernel;
-	const bound = bindRemote(definition, store);
+	const bound = bindRemote(definition, store, operators);
 	const readers = /* @__PURE__ */ new Map();
 	const keptConnections = /* @__PURE__ */ new Set();
 	/**
@@ -5570,7 +5608,7 @@ const bindDomain = (definition, store, options = {}) => {
 			pages,
 			layers,
 			remote.entities
-		], `placed:${identity}`, () => placedHeld(identity, pages, changesOf({ entities: resolvedPatches(remote.entities, remote.optimistic) }, remote.entities), visibleStoreOf(remote.entities, remote.optimistic)));
+		], `placed:${identity}`, () => placedHeld(identity, pages, changesOf({ entities: resolvedPatches(remote.entities, remote.optimistic, operators) }, remote.entities), visibleStoreOf(remote.entities, remote.optimistic, operators)));
 	};
 	/**
 	* The edges a loaded list shows: its pages with pending edits placed, and
@@ -5590,7 +5628,7 @@ const bindDomain = (definition, store, options = {}) => {
 	};
 	const insertsPlaced = (remote, identity, pages) => {
 		const { overlays } = remote.optimistic;
-		const store = visibleStoreOf(remote.entities, remote.optimistic);
+		const store = visibleStoreOf(remote.entities, remote.optimistic, operators);
 		return memoRead([
 			pages,
 			overlays,
@@ -5683,7 +5721,7 @@ const bindDomain = (definition, store, options = {}) => {
 			keys.add(change.edge.key);
 			named.set(change.connection, keys);
 		}
-		const visible = visibleStoreOf(remote.entities, remote.optimistic);
+		const visible = visibleStoreOf(remote.entities, remote.optimistic, operators);
 		const placed = {};
 		const invalidated = [];
 		for (const identity of Object.keys(remote.connections)) {
@@ -5770,11 +5808,11 @@ const bindDomain = (definition, store, options = {}) => {
 			const client = yield* RemoteClient;
 			const planOptions = RemotePolicy.toPlan(policy, now());
 			let current = model;
-			for (const query of planAsked(store.get(current), askedOf(projection), planOptions).queries) {
+			for (const query of planAsked(store.get(current), askedOf(projection), planOptions, operators).queries) {
 				const page = yield* queryRequestOf(query).pipe(Effect.flatMap((request) => client.query(request)));
 				current = hear(current, pageMessage(query.identity, page, true, query.window, query.select, now()));
 			}
-			const requirements = planAsked(store.get(current), askedOf(projection), planOptions).requirements;
+			const requirements = planAsked(store.get(current), askedOf(projection), planOptions, operators).requirements;
 			if (requirements.length === 0) return current;
 			const at = now();
 			const result = yield* client.read({
@@ -5795,7 +5833,7 @@ const bindDomain = (definition, store, options = {}) => {
 		entries.forEach(assertOwned);
 		const planOptions = RemotePolicy.toPlan(RemotePolicy.cacheFirst, now());
 		const plans = (current, projections) => {
-			const planned = planAsked(store.get(current), askedUnion(projections), planOptions);
+			const planned = planAsked(store.get(current), askedUnion(projections), planOptions, operators);
 			return planned.queries.length > 0 || planned.requirements.length > 0;
 		};
 		let current = model;
@@ -5907,7 +5945,7 @@ const bindDomain = (definition, store, options = {}) => {
 				}
 			};
 			const readPage = (remote, connection) => {
-				const visible = visibleStoreOf(remote.entities, remote.optimistic);
+				const visible = visibleStoreOf(remote.entities, remote.optimistic, operators);
 				return memoRead([
 					visible,
 					connection,
@@ -6095,7 +6133,7 @@ const bindDomain = (definition, store, options = {}) => {
 			if (filters !== void 0 && filters !== over.selection.entity) throw new Error(`Remote: query "${by.name}" is over "${filters}", but the list is of "${over.selection.entity}", so it cannot filter it`);
 			const remote = store.get(model);
 			const connection = remote.connections[over.ref.identity];
-			const visible = visibleStoreOf(remote.entities, remote.optimistic);
+			const visible = visibleStoreOf(remote.entities, remote.optimistic, operators);
 			const among = (connection === void 0 ? [] : shownEdges(remote, over.ref.identity, connection)).map((edge) => entityKey(edge.ref.entity, edge.ref.id));
 			let judged;
 			try {
@@ -6341,4 +6379,4 @@ const pickWindow = (window) => ({
 });
 export { emptyOptimistic as $, RelationEntityAnnotation as $n, PageSize as $t, writeRead as A, optimisticOfWrite as An, unknown as At, plan as B, isFieldUnavailable as Bn, requirementKey as Bt, remoteMessageCases as C, stableStringify as Cn, hasNext as Ct, updateRemote as D, emptyMutationState as Dn, merge as Dt, retentionRootsSchema as E, beginMutation as En, items as Et, REMOTE_CACHE_VERSION as F, emptyStore as Fn, mintOperation as Ft, emptyLiveState as G, remove as Gn, LiveRequirement as Gt, applyConnectionEvent as H, markStale as Hn, Live as Ht, RemotePersistence as I, entityKey as In, mutateRemote as It, ConnectionChange as J, tombstone as Jn, Mutate as Jt, liveHasNext as K, setStale as Kn, MAX_FIELDS_PER_REQUEST as Kt, gc as L, entry as Ln, remoteError as Lt, RemoteData as M, reconcileMutation as Mn, coalescedLayer as Mt, remoteDataSchema as N, schemaOf as Nn, connectionChangeOf as Nt, windowGrowthKey as O, failMutation as On, segment as Ot, remoteErrorSchema as P, clearStale as Pn, liveEventOf as Pt, connectionIdentity as Q, RelationAnnotation as Qn, OperationId as Qt, reachable as R, hasField as Rn, coalesceQueries as Rt, refreshedAt as S, Query$1 as Sn, emptyConnection as St, remoteModelSchema as T, Refusal as Tn, isGapped as Tt, applyEntityEvent as U, missingFields as Un, LiveChange as Ut, windowKey as V, isTombstone as Vn, ConnectionChangeSchema as Vt, classifyLive as W, readField as Wn, LiveEdge as Wt, addOverlay as X, writeEntity as Xn, MutationResult as Xt, addLayer as Y, writeEntities as Yn, MutationRequest as Yt, beginOptimistic as Z, RELATION_ALIAS as Zn, NormalizedEntity as Zt, isRemoteMessage as _, RemoteUnauthenticated as _n, pageSchema as _t, RemoteJsonAnswer as a, Read as an, relationShape as ar, settleSuccess as at, overlaysOf as b, WireBoundary as bn, cursor as bt, emptyRefresh as c, ReadRequest as cn, RemoteRequirements as cr, inspectEntity as ct, initialRemoteModel as d, RemoteLiveError as dn, requirementsOf as dr, matching as dt, QueryEdge as en, aliasedField as er, pruneOverlays as et, invalidateConnections as f, RemoteMutationError as fn, RowPlace as ft, isQueryLoading as g, RemoteRpc as gn, assemble as gt, isLoadingThrough as h, RemoteReadError as hn, Selection as ht, liveFetch as i, REMOTE_PROTOCOL_VERSION as in, relationAlias as ir, settleFailure as it, Denied as j, patchOfWrite as jn, RemoteClient as jt, withRefreshRequested as k, mutationStatus as kn, terminal as kt, failureOf as l, RelationRequest as ln, Requirement as lr, inspectRemote as lt, isLoading as m, RemoteQueryError as mn, Entity$1 as mt, RemoteUnsatisfied as n, QueryResult as nn, refParts as nr, removeOverlay as nt, RemoteJsonRequest as o, ReadBatch as on, targetsOf as or, visibleItems as ot, isFieldFailed as p, RemoteProtocolError as pn, placeIn as pt, liveHasPrevious as q, setUnavailable as qn, MAX_RELATION_DEPTH as qt, httpWithLive as r, QueryRpc as rn, refsIn as rr, resolvedPatches as rt, RemotePolicy as s, ReadBatchResult as sn, RemoteConnections as sr, visibleStore as st, Remote as t, QueryRequest as tn, isRefPage as tr, removeLayer as tt, forgetRemote as u, RemoteForbidden as un, connectionsOf as ur, belongsEncoded as ut, noFailures as v, SettledFields as vn, relationOf as vt, remoteMessageSchema as w, Mutation as wn, hasPrevious as wt, refreshIsInFlight as x, IDENTITY_SEPARATOR as xn, edge as xt, onlyOverlaid as y, WindowSchema as yn, unavailableOf as yt, deadlineOf as z, isFieldStale as zn, coalesceReads as zt };
 
-//# sourceMappingURL=src-BDqn7Ocr.mjs.map
+//# sourceMappingURL=src-lVP_7bf4.mjs.map