foldkit-remote 0.18.0 → 0.19.0

package/dist/{src-Cp71fJac.mjs → src-fsYu0YoT.mjs}

@@ -420,6 +420,7 @@ const emptyMutationState = {
 	applied: /* @__PURE__ */ new Set(),
 	failed: /* @__PURE__ */ new Set(),
 	errors: /* @__PURE__ */ new Map(),
+	operations: /* @__PURE__ */ new Map(),
 	sequence: 0
 };
 /**
@@ -442,17 +443,20 @@ const beginMutation = (state, requestId) => ({
 	pending: /* @__PURE__ */ new Set([...state.pending, requestId]),
 	sequence: state.sequence + 1
 });
-const failMutation = (state, requestId, error) => {
+const failMutation = (state, requestId, error, operation) => {
 	const pending = new Set(state.pending);
 	pending.delete(requestId);
 	const failed = remember(state.failed, requestId);
 	const errors = new Map([...state.errors, [requestId, error]]);
+	const operations = new Map([...state.operations, [requestId, operation]]);
 	for (const id of errors.keys()) if (!failed.has(id)) errors.delete(id);
+	for (const id of operations.keys()) if (!failed.has(id)) operations.delete(id);
 	return {
 		...state,
 		pending,
 		failed,
-		errors
+		errors,
+		operations
 	};
 };
 const mutationStatus = (state, requestId) => {
@@ -487,6 +491,23 @@ const reconcileMutation = (store, state, requestId, answer) => {
 	};
 };
 const conflict = Schema.TaggedStruct("Conflict", {});
+const unmet = Schema.TaggedStruct("Unmet", {});
+/**
+* The row the write would leave breaks one of its Entity's invariants: which
+* one, what to tell the author, and the fields to show it beside. None and
+* empty when the invariant reads a member hidden from whoever asked.
+*/
+const invalid = Schema.TaggedStruct("Invalid", {
+	rule: Schema.OptionFromNullOr(Schema.String),
+	message: Schema.String,
+	path: Schema.Array(Schema.String)
+});
+const conflictOrInvalid = Schema.Union([conflict, invalid]);
+const conflictUnmetOrInvalid = Schema.Union([
+	conflict,
+	unmet,
+	invalid
+]);
 const anyField = Schema.TaggedStruct("Field", {
 	key: Schema.String,
 	reason: Schema.Unknown
@@ -500,10 +521,24 @@ const Refusal = {
 	}),
 	/** The row moved on since the client read it; the author decides what wins. */
 	conflict,
+	/** The row does not hold what the write's `when` asks of it, where it would commit. */
+	unmet,
+	/** The row the write would leave breaks an invariant of its Entity. */
+	invalid,
 	/** Whether a refusal, of whatever mutation, is a `Refusal.field`. */
 	isField: Schema.is(anyField),
 	/** Whether a refusal, of whatever mutation, is `Refusal.conflict`. */
-	isConflict: Schema.is(conflict)
+	isConflict: Schema.is(conflict),
+	/** Whether a refusal, of whatever mutation, is `Refusal.unmet`. */
+	isUnmet: Schema.is(unmet),
+	/** Whether a refusal, of whatever mutation, is `Refusal.invalid`. */
+	isInvalid: Schema.is(invalid),
+	/**
+	* Whether a refusal is `Refusal.invalid` naming this invariant: the one
+	* `Entity.invariant` returned, or one `Entity.invariants` reads. An invariant
+	* over a member hidden from the asker names none, so it matches nothing.
+	*/
+	isInvalidBy: (refusal, invariant) => Schema.is(invalid)(refusal) && Option.contains(refusal.rule, invariant.id)
 };
 /** The codec itself, or a `Schema.Struct` over the fields. */
 const schemaOf = (shape) => Schema.isSchema(shape) ? shape : Schema.Struct(shape);
@@ -525,11 +560,18 @@ 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). A delete shows nothing, since no operation removes a row from every
+* 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.
 */
 const optimisticOfWrite = (write, input, keys) => Match.value(write).pipe(Match.tagsExhaustive({
-	Update: () => [patchOfWrite(Write.bind(write, input, keys))],
+	Update: () => {
+		const bound = Write.bind(write, input, keys);
+		const patch = patchOfWrite(bound);
+		return [Object.keys(bound.increments).length === 0 ? patch : {
+			...patch,
+			adds: bound.increments
+		}];
+	},
 	Insert: () => {
 		const patch = patchOfWrite(Write.bind(write, input));
 		return [{
@@ -553,13 +595,14 @@ const Mutation = {
 	* A mutation that is a declared `Write` (`update`, `insert` or `delete`): its
 	* input is the write's, and it answers nothing but the row it changed, as a
 	* patch, or its deletion. It may be refused as a conflict, for a write that
-	* `expect`s a revision the row has moved past.
+	* `expect`s a revision the row has moved past, for a write with a `when` as
+	* unmet, and as invalid when the row it would leave breaks an invariant.
 	*/
 	write: (name, write) => ({
 		name,
 		Input: write.input.schema,
 		Output: Schema.Struct({}),
-		Refusal: Refusal.conflict,
+		Refusal: Option.isSome(write.when) ? conflictUnmetOrInvalid : conflictOrInvalid,
 		write
 	}),
 	make: (name, config) => ({
@@ -822,9 +865,21 @@ const ReadBatchResult = Schema.Struct({
 	entities: Schema.Array(NormalizedEntity),
 	settled: Schema.Array(SettledFields)
 });
+/**
+* One operation's identity across every client: minted where it is first sent
+* and sent again with each retry of it. Bounded, since a server keys a record
+* of the write by it.
+*/
+const OperationId = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(128), Schema.isPattern(/^[A-Za-z0-9:._-]+$/));
 const MutationRequest = Schema.Struct({
-	/** Stable across transport retries so a mutation is not applied twice. */
+	/**
+	* This client's id for the request, the same on each retry of it. It is
+	* unique within one client's Model only (a counter there), so it names a
+	* request to that client; `operation` names it to a server.
+	*/
 	requestId: Schema.String,
+	/** The operation's identity across clients: what a server keys a record of the write by. */
+	operation: Schema.optional(OperationId),
 	mutation: Schema.String,
 	input: Schema.Unknown,
 	/** For a mutation that is a `Write`: the input keys to write, when not all of them. */
@@ -1198,18 +1253,28 @@ const coalescedLayer = (layer, options = {}) => Layer.effect(RemoteClient, Effec
 	};
 })).pipe(Layer.provide(layer));
 /**
+* A new operation's identity: random, so unique across clients and reloads.
+* `randomUUID` exists only in a secure context, so a page served over plain
+* HTTP draws 128 random bits from `getRandomValues`, which exists in all.
+*/
+const mintOperation = () => typeof globalThis.crypto.randomUUID === "function" ? globalThis.crypto.randomUUID() : Array.from(globalThis.crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16)), (byte) => byte.toString(16).padStart(2, "0")).join("");
+/**
 * `Remote.mutate` as a standalone effect, so `Remote.mutateInto` can reuse it
 * without the object literal referencing itself.
 */
-const mutateRemote = Effect.fn("Remote.mutate")(function* (mutation, input, requestId, keys) {
+const mutateRemote = Effect.fn("Remote.mutate")(function* (mutation, input, requestId, options = {}) {
+	const { keys } = options;
+	const operation = options.operation ?? (yield* Effect.sync(mintOperation));
 	yield* Effect.annotateCurrentSpan({
 		mutation: mutation.name,
-		requestId
+		requestId,
+		operation
 	});
 	const client = yield* RemoteClient;
 	const encoded = yield* Schema.encodeUnknownEffect(mutation.Input)(input).pipe(Effect.catchTag("SchemaError", (error) => Effect.fail(new RemoteMutationError({ message: error.message }))));
 	const result = yield* client.mutate({
 		requestId,
+		operation,
 		mutation: mutation.name,
 		input: encoded,
 		...keys === void 0 ? {} : { keys }
@@ -2137,7 +2202,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, optimistic.layers.flatMap((layer) => layer.patches.map((patch) => {
+const visibleStore = (base, optimistic) => writeEntities(base, resolvedPatches(base, optimistic).map((patch) => {
 	const key = entityKey(patch.entity, patch.id);
 	const under = base[key];
 	return {
@@ -2145,7 +2210,34 @@ const visibleStore = (base, optimistic) => writeEntities(base, optimistic.layers
 		values: patch.values,
 		updatedAt: under === void 0 || under.tombstone ? Infinity : under.updatedAt
 	};
-})));
+}));
+/**
+* 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.
+*/
+const resolvedPatches = (base, optimistic) => {
+	const shown = /* @__PURE__ */ new Map();
+	return optimistic.layers.flatMap((layer) => layer.patches.map(({ adds, ...patch }) => {
+		const key = entityKey(patch.entity, patch.id);
+		const earlier = shown.get(key) ?? {};
+		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;
+		});
+		shown.set(key, {
+			...earlier,
+			...values
+		});
+		return {
+			...patch,
+			values
+		};
+	}));
+};
 /**
 * 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
@@ -2991,7 +3083,8 @@ const remoteMessageCases = {
 	},
 	MutationFailed: {
 		requestId: Schema.String,
-		error: remoteErrorSchema
+		error: remoteErrorSchema,
+		operation: Schema.String
 	},
 	OverlayShown: {
 		id: Schema.String,
@@ -3432,7 +3525,7 @@ const reduceRemote = (model, message) => {
 		}
 		case "MutationFailed": return {
 			...model,
-			mutations: failMutation(model.mutations, message.requestId, message.error),
+			mutations: failMutation(model.mutations, message.requestId, message.error, message.operation),
 			optimistic: settleFailure(model.optimistic, message.requestId)
 		};
 		case "LiveReceived": {
@@ -5492,7 +5585,7 @@ const bindDomain = (definition, store, options = {}) => {
 			pages,
 			layers,
 			remote.entities
-		], `placed:${identity}`, () => placedHeld(identity, pages, changesOf({ entities: layers.flatMap((layer) => layer.patches) }, remote.entities), visibleStoreOf(remote.entities, remote.optimistic)));
+		], `placed:${identity}`, () => placedHeld(identity, pages, changesOf({ entities: resolvedPatches(remote.entities, remote.optimistic) }, remote.entities), visibleStoreOf(remote.entities, remote.optimistic)));
 	};
 	/**
 	* The edges a loaded list shows: its pages with pending edits placed, and
@@ -6071,6 +6164,7 @@ const bindDomain = (definition, store, options = {}) => {
 			const remote = store.get(model);
 			const requestId = options.requestId ?? `${bound.contract.name}-${remote.mutations.sequence + 1}`;
 			const tempId = `${requestId}.tmp`;
+			const known = Option.fromUndefinedOr(remote.mutations.operations.get(requestId));
 			const optimistic = typeof options.optimistic === "function" ? options.optimistic({
 				requestId,
 				tempId
@@ -6087,11 +6181,15 @@ const bindDomain = (definition, store, options = {}) => {
 				command: {
 					name: `Remote.mutate(${mutation.name})`,
 					args: { requestId },
-					effect: mutateRemote(mutation, input, requestId, options.keys).pipe(Effect.match({
+					effect: Effect.flatMap(Effect.sync(() => Option.getOrElse(known, mintOperation)), (operation) => mutateRemote(mutation, input, requestId, {
+						keys: options.keys,
+						operation
+					}).pipe(Effect.match({
 						onFailure: (error) => ({
 							_tag: "MutationFailed",
 							requestId,
-							error: remoteError(error)
+							error: remoteError(error),
+							operation
 						}),
 						onSuccess: (outcome) => ({
 							_tag: "MutationSucceeded",
@@ -6101,7 +6199,7 @@ const bindDomain = (definition, store, options = {}) => {
 							deleted: outcome.deleted,
 							now: (options.now ?? wallClock)()
 						})
-					}))
+					})))
 				}
 			};
 		},
@@ -6254,6 +6352,6 @@ const pickWindow = (window) => ({
 	...window.before === void 0 ? {} : { before: window.before }
 });
 //#endregion
-export { emptyOptimistic as $, refParts as $n, QueryResult as $t, writeRead as A, schemaOf as An, RemoteClient as At, plan as B, missingFields as Bn, Live as Bt, remoteMessageCases as C, beginMutation as Cn, hasPrevious as Ct, updateRemote as D, optimisticOfWrite as Dn, segment as Dt, retentionRootsSchema as E, mutationStatus as En, merge as Et, REMOTE_CACHE_VERSION as F, hasField as Fn, remoteError as Ft, emptyLiveState as G, tombstone as Gn, MAX_RELATION_DEPTH as Gt, applyConnectionEvent as H, remove as Hn, LiveEdge as Ht, RemotePersistence as I, isFieldStale as In, coalesceQueries as It, ConnectionChange as J, RELATION_ALIAS as Jn, MutationResult as Jt, liveHasNext as K, writeEntities as Kn, Mutate as Kt, gc as L, isFieldUnavailable as Ln, coalesceReads as Lt, RemoteData as M, emptyStore as Mn, connectionChangeOf as Mt, remoteDataSchema as N, entityKey as Nn, liveEventOf as Nt, windowGrowthKey as O, patchOfWrite as On, terminal as Ot, remoteErrorSchema as P, entry as Pn, mutateRemote as Pt, connectionIdentity as Q, isRefPage as Qn, QueryRequest as Qt, reachable as R, isTombstone as Rn, requirementKey as Rt, refreshedAt as S, Refusal as Sn, hasNext as St, remoteModelSchema as T, failMutation as Tn, items as Tt, applyEntityEvent as U, setStale as Un, LiveRequirement as Ut, windowKey as V, readField as Vn, LiveChange as Vt, classifyLive as W, setUnavailable as Wn, MAX_FIELDS_PER_REQUEST as Wt, addOverlay as X, RelationEntityAnnotation as Xn, PageSize as Xt, addLayer as Y, RelationAnnotation as Yn, NormalizedEntity as Yt, beginOptimistic as Z, aliasedField as Zn, QueryEdge as Zt, isRemoteMessage as _, WireBoundary as _n, relationOf as _t, RemoteJsonAnswer as a, ReadRequest as an, RemoteRequirements as ar, visibleItems as at, overlaysOf as b, stableStringify as bn, edge as bt, emptyRefresh as c, RemoteLiveError as cn, requirementsOf as cr, inspectRemote as ct, initialRemoteModel as d, RemoteQueryError as dn, RowPlace as dt, QueryRpc as en, refsIn as er, pruneOverlays as et, invalidateConnections as f, RemoteReadError as fn, placeIn as ft, isQueryLoading as g, WindowSchema as gn, pageSchema as gt, isLoadingThrough as h, SettledFields as hn, assemble as ht, liveFetch as i, ReadBatchResult as in, RemoteConnections as ir, settleSuccess as it, Denied as j, clearStale as jn, coalescedLayer as jt, withRefreshRequested as k, reconcileMutation as kn, unknown as kt, failureOf as l, RemoteMutationError as ln, belongsEncoded as lt, isLoading as m, RemoteUnauthenticated as mn, Selection as mt, RemoteUnsatisfied as n, Read as nn, relationShape as nr, removeOverlay as nt, RemoteJsonRequest as o, RelationRequest as on, Requirement as or, visibleStore as ot, isFieldFailed as p, RemoteRpc as pn, Entity$1 as pt, liveHasPrevious as q, writeEntity as qn, MutationRequest as qt, httpWithLive as r, ReadBatch as rn, targetsOf as rr, settleFailure as rt, RemotePolicy as s, RemoteForbidden as sn, connectionsOf as sr, inspectEntity as st, Remote as t, REMOTE_PROTOCOL_VERSION as tn, relationAlias as tr, removeLayer as tt, forgetRemote as u, RemoteProtocolError as un, matching as ut, noFailures as v, IDENTITY_SEPARATOR as vn, unavailableOf as vt, remoteMessageSchema as w, emptyMutationState as wn, isGapped as wt, refreshIsInFlight as x, Mutation as xn, emptyConnection as xt, onlyOverlaid as y, Query$1 as yn, cursor as yt, deadlineOf as z, markStale as zn, ConnectionChangeSchema as zt };
+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-Cp71fJac.mjs.map
+//# sourceMappingURL=src-fsYu0YoT.mjs.map