foldkit-remote 0.21.0 → 0.22.0

package/dist/impact.js

@@ -0,0 +1,166 @@
+import { sameData } from "./data.js";
+import { entityKey } from "./store.js";
+import { edge, hasNext, hasPrevious, isGapped } from "./connection.js";
+import { RowPlace, placeIn, withEdge, withoutEdge } from "./placement.js";
+import { belongsEncoded } from "./matching.js";
+import { Data, Match, Option, Schema } from "effect";
+import { Query, dependenciesOf } from "foldkit-entity";
+import { defineTaggedUnion } from "foldkit/schema";
+// src/impact.ts
+/**
+* What a write did to the lists the client holds: given one change and one
+* loaded connection, whether the connection is still right as it stands.
+*
+* Pure, and asked once per connection a write could touch. The answer is never
+* a guess: a connection kept must be provably unchanged in which rows it holds
+* and in what order, a connection placed is the client's exact deduction of
+* what the server now lists, and everything else is invalidated, with the
+* reason, for the read entry to fetch again.
+*
+* Membership is judged by the query's body, as a live insert is
+* (`belongsEncoded`), and position by its declared order (`placeIn`), when
+* the order is placeable. A body that names no order leaves it to the server,
+* by fields the client cannot see, so any change to a row it holds
+* invalidates it.
+*/
+/**
+* One row a write changed: the fields it wrote, and whether the client held
+* no values of the row before (`created`), or its deletion.
+*/
+const EntityChange = defineTaggedUnion({
+	Changed: {
+		entity: Schema.String,
+		id: Schema.String,
+		fields: Schema.Array(Schema.String),
+		created: Schema.Boolean
+	},
+	Deleted: {
+		entity: Schema.String,
+		id: Schema.String
+	}
+});
+/**
+* What a mutation's answer changed, against `before`, the store as the server
+* last said it: each patch's fields whose value is new, and each deletion. An
+* answer returns more than it changed (a whole row, say), and counting an
+* unchanged ordering field would refetch every list on every save.
+*/
+const changesOf = (answer, before) => [...answer.entities.flatMap((patch) => {
+	const held = before[entityKey(patch.entity, patch.id)]?.values;
+	const fields = Object.keys(patch.values).filter((field) => held === void 0 || !Object.hasOwn(held, field) || !sameData(held[field], patch.values[field]));
+	return fields.length === 0 ? [] : [EntityChange.Changed({
+		entity: patch.entity,
+		id: patch.id,
+		fields,
+		created: held === void 0
+	})];
+}), ...(answer.deleted ?? []).map((gone) => EntityChange.Deleted({
+	entity: gone.entity,
+	id: gone.id
+}))];
+const Impact = Data.taggedEnum();
+const kept = Impact.Kept();
+const reachedBy = /* @__PURE__ */ new WeakMap();
+const reachedOf = (body) => {
+	const known = reachedBy.get(body);
+	if (known !== void 0) return known;
+	const own = /* @__PURE__ */ new Set();
+	const others = /* @__PURE__ */ new Map();
+	const other = (entity, key) => {
+		const keys = others.get(entity) ?? /* @__PURE__ */ new Set();
+		keys.add(key);
+		others.set(entity, keys);
+	};
+	/** Relations followed from the judged row: the first is its own link, the rest other rows'. */
+	const fromRow = (via) => via.forEach((relation, index) => index === 0 ? own.add(relation.key) : other(relation.owner.name, relation.key));
+	for (const reach of Query.dependencies(body).reaches) Match.value(reach).pipe(Match.tagsExhaustive({
+		Path: (path) => {
+			fromRow(path.via);
+			other(path.field.owner.name, path.field.key);
+		},
+		Exists: (exists) => {
+			fromRow(exists.via);
+			other(exists.relation.owner.name, exists.relation.key);
+			Option.map(exists.where, (where) => dependenciesOf(where).fields.forEach((field) => other(field.entity, field.key)));
+		},
+		ViewerPath: (path) => {
+			for (const relation of path.via) other(relation.owner.name, relation.key);
+			other(path.field.owner.name, path.field.key);
+		}
+	}));
+	const reached = {
+		own,
+		others
+	};
+	reachedBy.set(body, reached);
+	return reached;
+};
+/** Whether two versions of a list hold the same rows in the same order, segment by segment. */
+const sameOrder = (left, right) => left.segments.length === right.segments.length && left.segments.every((segment, index) => {
+	const other = right.segments[index].edges;
+	return segment.edges.length === other.length && segment.edges.every((edge, position) => edge.key === other[position].key);
+});
+/**
+* What `change` does to `connection`, judged against `store`, the store after
+* the write.
+*/
+const impactOn = (connection, store, change, operators, context) => {
+	const { descriptor } = connection;
+	const body = descriptor.body;
+	const over = body?.entity.name ?? descriptor.Result.entity;
+	const reached = body === void 0 ? void 0 : reachedOf(body);
+	const read = reached?.others.get(change.entity);
+	if (read !== void 0 && EntityChange.match(change, {
+		Deleted: () => true,
+		Changed: ({ fields }) => fields.some((field) => read.has(field))
+	})) return Impact.Invalidated({ reason: `${entityKey(change.entity, change.id)} changed what "${descriptor.name}" reads through another row` });
+	if (over !== change.entity) return kept;
+	return EntityChange.match(change, {
+		Deleted: () => kept,
+		Changed: ({ fields, created }) => {
+			if (body === void 0) return Impact.Invalidated({ reason: `query "${descriptor.name}" declares no body, so what it reads is unknown` });
+			const key = entityKey(change.entity, change.id);
+			const held = connection.holds.has(key);
+			const ruled = fields.find((field) => connection.filtered.includes(field));
+			if (!held && ruled !== void 0) return Impact.Invalidated({ reason: `${key} changed "${ruled}", which the server's read rule for ${change.entity} filters on` });
+			const roles = Query.dependencies(body);
+			const touches = (keys) => keys.some((field) => fields.includes(field.key));
+			let order;
+			try {
+				order = Query.orderFor(body, connection.encoded);
+			} catch {
+				return Impact.Invalidated({ reason: `"${descriptor.name}" was read in an order its body does not offer` });
+			}
+			if (held && body.orderBy.length === 0) return Impact.Invalidated({ reason: `${key} changed, and "${descriptor.name}" is ordered by the server, by fields its body does not name` });
+			const pages = connection.connection;
+			const reorders = touches(dependenciesOf(...order).fields);
+			const refilters = touches(roles.predicate) || fields.some((field) => reached?.own.has(field) === true);
+			const unloaded = hasPrevious(pages) || hasNext(pages) || isGapped(pages);
+			if (!(held && reorders) && !refilters && !(!held && (created || reorders && unloaded))) return kept;
+			const belongs = held && !refilters ? "yes" : belongsEncoded(store, descriptor, connection.encoded, key, operators, context);
+			if (belongs === "unknown") return Impact.Invalidated({ reason: `${key} changed a field "${descriptor.name}" filters on, and the client cannot judge it` });
+			if (!held && belongs === "no") return kept;
+			if (held && belongs === "yes" && !reorders) return kept;
+			const inPages = pages.segments.some((segment) => segment.edges.some((edge) => edge.key === key));
+			if (held && !inPages) return Impact.Invalidated({ reason: `${key} is shown in "${descriptor.name}" by an overlay, which a placement does not move` });
+			if (belongs === "no") return Impact.Placed({ connection: withoutEdge(pages, key) });
+			/** The row where `place` says; the list as it was when that is where it already stood. */
+			const placedAt = (place) => {
+				const next = withEdge(withoutEdge(pages, key), edge({
+					entity: change.entity,
+					id: change.id
+				}), place);
+				return sameOrder(pages, next) ? kept : Impact.Placed({ connection: next });
+			};
+			return RowPlace.$match(placeIn(store, pages, body, connection.encoded, key, operators), {
+				Before: placedAt,
+				End: placedAt,
+				Outside: () => held ? Impact.Placed({ connection: withoutEdge(pages, key) }) : kept,
+				Unknown: ({ reason }) => Impact.Invalidated({ reason: `${key} ${held ? "moved in" : "joined"} "${descriptor.name}", and cannot be placed: ${reason}` })
+			});
+		}
+	});
+};
+export { EntityChange, Impact, changesOf, impactOn };
+
+//# sourceMappingURL=impact.js.map

package/dist/impact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"impact.js","names":["Relational"],"sources":["../src/impact.ts"],"sourcesContent":["/**\n * What a write did to the lists the client holds: given one change and one\n * loaded connection, whether the connection is still right as it stands.\n *\n * Pure, and asked once per connection a write could touch. The answer is never\n * a guess: a connection kept must be provably unchanged in which rows it holds\n * and in what order, a connection placed is the client's exact deduction of\n * what the server now lists, and everything else is invalidated, with the\n * reason, for the read entry to fetch again.\n *\n * Membership is judged by the query's body, as a live insert is\n * (`belongsEncoded`), and position by its declared order (`placeIn`), when\n * the order is placeable. A body that names no order leaves it to the server,\n * by fields the client cannot see, so any change to a row it holds\n * invalidates it.\n */\nimport {\n  Query as Relational,\n  dependenciesOf,\n  type AnyQuery,\n  type ExprContext,\n  type MemoryOperators,\n  type OneRelation,\n  type OrderTerm,\n} from 'foldkit-entity'\nimport { defineTaggedUnion } from 'foldkit/schema'\nimport { edge, hasNext, hasPrevious, isGapped, type Connection } from './connection.js'\nimport { RowPlace, placeIn, withEdge, withoutEdge } from './placement.js'\nimport { Data, Match, Option, Schema } from 'effect'\nimport { sameData } from './data.js'\nimport { belongsEncoded } from './matching.js'\nimport type { NormalizedPatch } from './mutation.js'\nimport type { ConnectionSpec, QueryDescriptor } from './query.js'\nimport { entityKey, type EntityKey, type EntityStore } from './store.js'\n\n/**\n * One row a write changed: the fields it wrote, and whether the client held\n * no values of the row before (`created`), or its deletion.\n */\nexport const EntityChange = defineTaggedUnion({\n  Changed: {\n    entity: Schema.String,\n    id: Schema.String,\n    fields: Schema.Array(Schema.String),\n    created: Schema.Boolean,\n  },\n  Deleted: { entity: Schema.String, id: Schema.String },\n})\nexport type EntityChange = typeof EntityChange.Type\n\n/**\n * What a mutation's answer changed, against `before`, the store as the server\n * last said it: each patch's fields whose value is new, and each deletion. An\n * answer returns more than it changed (a whole row, say), and counting an\n * unchanged ordering field would refetch every list on every save.\n */\nexport const changesOf = (\n  answer: {\n    readonly entities: ReadonlyArray<NormalizedPatch>\n    readonly deleted?: ReadonlyArray<{ readonly entity: string; readonly id: string }> | undefined\n  },\n  before: EntityStore,\n): ReadonlyArray<EntityChange> => [\n  ...answer.entities.flatMap(patch => {\n    const held = before[entityKey(patch.entity, patch.id)]?.values\n    const fields = Object.keys(patch.values).filter(\n      field =>\n        held === undefined ||\n        !Object.hasOwn(held, field) ||\n        !sameData(held[field], patch.values[field]),\n    )\n    return fields.length === 0\n      ? []\n      : [\n          EntityChange.Changed({\n            entity: patch.entity,\n            id: patch.id,\n            fields,\n            created: held === undefined,\n          }),\n        ]\n  }),\n  ...(answer.deleted ?? []).map(gone => EntityChange.Deleted({ entity: gone.entity, id: gone.id })),\n]\n\n/**\n * What a change does to a connection: nothing it shows, a change the client\n * places itself (`Placed`, the connection as it now is), or a change it\n * cannot place, for its read entry to fetch again.\n */\nexport type Impact = Data.TaggedEnum<{\n  Kept: {}\n  Placed: { readonly connection: Connection }\n  Invalidated: { readonly reason: string }\n}>\nexport const Impact = Data.taggedEnum<Impact>()\n\n/** A loaded connection, as impact needs it. */\nexport interface HeldConnection {\n  readonly descriptor: QueryDescriptor<string, unknown, unknown>\n  /** The connection's input, encoded, as its identity carries it. */\n  readonly encoded: Readonly<Record<string, unknown>>\n  /** The rows it shows now, overlays included. */\n  readonly holds: ReadonlySet<EntityKey>\n  /** Its pages as the server sent them, which a placement edits. */\n  readonly connection: Connection\n  /** The members its Entity's server filters rows by under a rule the client does not run. */\n  readonly filtered: ReadonlyArray<string>\n}\n\nconst kept = Impact.Kept()\n\n/**\n * What a body's paths, exists and paths from the viewer read beyond the\n * fields of the row judged: `own`, the links of that row a path starts from,\n * which a change re-judges for that row alone; `others`, by Entity name, the\n * members they read in other rows, a change to any of which may move any row\n * of the list.\n */\ninterface Reached {\n  readonly own: ReadonlySet<string>\n  readonly others: ReadonlyMap<string, ReadonlySet<string>>\n}\n\nconst reachedBy = new WeakMap<AnyQuery, Reached>()\n\nconst reachedOf = (body: AnyQuery): Reached => {\n  const known = reachedBy.get(body)\n  if (known !== undefined) return known\n  const own = new Set<string>()\n  const others = new Map<string, Set<string>>()\n  const other = (entity: string, key: string) => {\n    const keys = others.get(entity) ?? new Set<string>()\n    keys.add(key)\n    others.set(entity, keys)\n  }\n  /** Relations followed from the judged row: the first is its own link, the rest other rows'. */\n  const fromRow = (via: ReadonlyArray<OneRelation>) =>\n    via.forEach((relation, index) =>\n      index === 0 ? own.add(relation.key) : other(relation.owner.name, relation.key),\n    )\n  for (const reach of Relational.dependencies(body).reaches)\n    Match.value(reach).pipe(\n      Match.tagsExhaustive({\n        Path: path => {\n          fromRow(path.via)\n          other(path.field.owner.name, path.field.key)\n        },\n        Exists: exists => {\n          fromRow(exists.via)\n          other(exists.relation.owner.name, exists.relation.key)\n          Option.map(exists.where, where =>\n            dependenciesOf(where).fields.forEach(field => other(field.entity, field.key)),\n          )\n        },\n        ViewerPath: path => {\n          for (const relation of path.via) other(relation.owner.name, relation.key)\n          other(path.field.owner.name, path.field.key)\n        },\n      }),\n    )\n  const reached = { own, others }\n  reachedBy.set(body, reached)\n  return reached\n}\n\n/** Whether two versions of a list hold the same rows in the same order, segment by segment. */\nconst sameOrder = (left: Connection, right: Connection): boolean =>\n  left.segments.length === right.segments.length &&\n  left.segments.every((segment, index) => {\n    const other = right.segments[index]!.edges\n    return (\n      segment.edges.length === other.length &&\n      segment.edges.every((edge, position) => edge.key === other[position]!.key)\n    )\n  })\n\n/**\n * What `change` does to `connection`, judged against `store`, the store after\n * the write.\n */\nexport const impactOn = (\n  connection: HeldConnection,\n  store: EntityStore,\n  change: EntityChange,\n  operators: MemoryOperators,\n  /** What a body's `Expr.viewer` and `Expr.now` read; see `MatchingOptions.context`. */\n  context?: ExprContext | undefined,\n): Impact => {\n  const { descriptor } = connection\n  const body = descriptor.body\n  const over = body?.entity.name ?? (descriptor.Result as Partial<ConnectionSpec>).entity\n  const reached = body === undefined ? undefined : reachedOf(body)\n  // A row another reads through a path or an exists: any row of the list may have moved.\n  const read = reached?.others.get(change.entity)\n  if (\n    read !== undefined &&\n    EntityChange.match(change, {\n      Deleted: () => true,\n      Changed: ({ fields }) => fields.some(field => read.has(field)),\n    })\n  ) {\n    return Impact.Invalidated({\n      reason: `${entityKey(change.entity, change.id)} changed what \"${descriptor.name}\" reads through another row`,\n    })\n  }\n  if (over !== change.entity) return kept\n  return EntityChange.match(change, {\n    // A deletion leaves every list through its tombstone; nothing to fetch.\n    Deleted: () => kept,\n    Changed: ({ fields, created }) => {\n      if (body === undefined) {\n        return Impact.Invalidated({\n          reason: `query \"${descriptor.name}\" declares no body, so what it reads is unknown`,\n        })\n      }\n      const key = entityKey(change.entity, change.id)\n      const held = connection.holds.has(key)\n      // The server lists only the rows its read rules admit, and the client\n      // runs none of them: a row this list does not hold may have joined it\n      // on a change to what those rules read, which only the server can say.\n      const ruled = fields.find(field => connection.filtered.includes(field))\n      if (!held && ruled !== undefined) {\n        return Impact.Invalidated({\n          reason: `${key} changed \"${ruled}\", which the server's read rule for ${change.entity} filters on`,\n        })\n      }\n      const roles = Relational.dependencies(body)\n      const touches = (keys: ReadonlyArray<{ readonly key: string }>) =>\n        keys.some(field => fields.includes(field.key))\n      // The order this list was read in: a chosen order is the field its own\n      // input names, not every field it could have named.\n      let order: ReadonlyArray<OrderTerm>\n      try {\n        order = Relational.orderFor(body, connection.encoded)\n      } catch {\n        return Impact.Invalidated({\n          reason: `\"${descriptor.name}\" was read in an order its body does not offer`,\n        })\n      }\n\n      if (held && body.orderBy.length === 0) {\n        return Impact.Invalidated({\n          reason: `${key} changed, and \"${descriptor.name}\" is ordered by the server, by fields its body does not name`,\n        })\n      }\n      const pages = connection.connection\n      const reorders = touches(dependenciesOf(...order).fields)\n      const refilters =\n        touches(roles.predicate) || fields.some(field => reached?.own.has(field) === true)\n      // A row the list does not hold can join it: one new to the client,\n      // whatever the list filters on, and one whose order moved it in from\n      // rows the list has not loaded.\n      const unloaded = hasPrevious(pages) || hasNext(pages) || isGapped(pages)\n      const joins = !held && (created || (reorders && unloaded))\n      if (!(held && reorders) && !refilters && !joins) return kept\n\n      // A held row whose order alone changed still matches.\n      const belongs =\n        held && !refilters\n          ? 'yes'\n          : belongsEncoded(store, descriptor, connection.encoded, key, operators, context)\n      if (belongs === 'unknown') {\n        return Impact.Invalidated({\n          reason: `${key} changed a field \"${descriptor.name}\" filters on, and the client cannot judge it`,\n        })\n      }\n      // Not held and still not matching, or held and still matching where it was.\n      if (!held && belongs === 'no') return kept\n      if (held && belongs === 'yes' && !reorders) return kept\n\n      // The list's rows, or their order, changed: placed where the client can.\n      const inPages = pages.segments.some(segment => segment.edges.some(edge => edge.key === key))\n      if (held && !inPages) {\n        return Impact.Invalidated({\n          reason: `${key} is shown in \"${descriptor.name}\" by an overlay, which a placement does not move`,\n        })\n      }\n      // Leaving is exact whatever the order: membership is the body's.\n      if (belongs === 'no') return Impact.Placed({ connection: withoutEdge(pages, key) })\n      /** The row where `place` says; the list as it was when that is where it already stood. */\n      const placedAt = (place: Extract<RowPlace, { readonly _tag: 'Before' | 'End' }>) => {\n        const next = withEdge(\n          withoutEdge(pages, key),\n          edge({ entity: change.entity, id: change.id }),\n          place,\n        )\n        return sameOrder(pages, next) ? kept : Impact.Placed({ connection: next })\n      }\n      return RowPlace.$match(placeIn(store, pages, body, connection.encoded, key, operators), {\n        Before: placedAt,\n        End: placedAt,\n        // It belongs to rows not loaded: gone from these, if they showed it.\n        Outside: () => (held ? Impact.Placed({ connection: withoutEdge(pages, key) }) : kept),\n        Unknown: ({ reason }) =>\n          Impact.Invalidated({\n            reason: `${key} ${held ? 'moved in' : 'joined'} \"${descriptor.name}\", and cannot be placed: ${reason}`,\n          }),\n      })\n    },\n  })\n}\n"],"mappings":"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"}