@absolutejs/sync 0.1.0 → 0.2.0

package/dist/engine/index.js

@@ -614,12 +614,98 @@ var createPollingChangeSource = (options) => {
     }
   };
 };
+// src/engine/cluster.ts
+var createInMemoryClusterBus = () => {
+  const listeners = new Set;
+  return {
+    publish: (message) => {
+      for (const listener of listeners) {
+        listener(message);
+      }
+    },
+    subscribe: (onMessage) => {
+      listeners.add(onMessage);
+      return () => {
+        listeners.delete(onMessage);
+      };
+    }
+  };
+};
+// src/engine/presence.ts
+var createPresenceHub = () => {
+  const rooms = new Map;
+  const roomMembers = (room) => {
+    const members = rooms.get(room);
+    if (members === undefined) {
+      return [];
+    }
+    return [...members].map(([id, member]) => ({
+      id,
+      state: member.state
+    }));
+  };
+  const notify = (room, diff, exceptId) => {
+    const members = rooms.get(room);
+    if (members === undefined) {
+      return;
+    }
+    for (const [id, member] of members) {
+      if (id !== exceptId) {
+        member.onDiff(diff);
+      }
+    }
+  };
+  return {
+    join: (room, memberId, state, onDiff) => {
+      let members = rooms.get(room);
+      if (members === undefined) {
+        members = new Map;
+        rooms.set(room, members);
+      }
+      members.set(memberId, {
+        state,
+        onDiff
+      });
+      notify(room, { joined: [{ id: memberId, state }], updated: [], left: [] }, memberId);
+      const snapshot = roomMembers(room);
+      return {
+        members: snapshot,
+        set: (next) => {
+          const current = rooms.get(room)?.get(memberId);
+          if (current === undefined) {
+            return;
+          }
+          current.state = next;
+          notify(room, {
+            joined: [],
+            updated: [{ id: memberId, state: next }],
+            left: []
+          }, memberId);
+        },
+        leave: () => {
+          const roomNow = rooms.get(room);
+          if (roomNow?.delete(memberId) !== true) {
+            return;
+          }
+          notify(room, { joined: [], updated: [], left: [memberId] }, memberId);
+          if (roomNow.size === 0) {
+            rooms.delete(room);
+          }
+        }
+      };
+    },
+    members: (room) => roomMembers(room),
+    count: (room) => rooms.get(room)?.size ?? 0
+  };
+};
 // src/engine/collection.ts
 var defineCollection = (definition) => definition;
 var defineJoinCollection = (definition) => ({
   ...definition,
   kind: "join"
 });
+// src/engine/reactive.ts
+var defineReactiveQuery = (definition) => ({ ...definition, kind: "reactive" });
 // src/engine/graph.ts
 var PLANS = new WeakMap;
 var planTables = (plan) => {
@@ -807,14 +893,36 @@ class UnauthorizedError extends Error {
   }
 }
 var defaultKey = (row) => row.id;
+var shallowEqual4 = (a, b) => {
+  if (a === b) {
+    return true;
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return false;
+  }
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  return aKeys.length === bKeys.length && aKeys.every((k) => a[k] === b[k]);
+};
 var createSyncEngine = (options = {}) => {
   const registry = new Map;
   const mutations = new Map;
+  const writers = new Map;
+  const readers = new Map;
+  const reactiveSubs = new Set;
   const active = new Map;
   const tableIndex = new Map;
   const changeLogSize = options.changeLogSize ?? 1024;
   const changeLog = [];
   let version = 0;
+  const runInTransaction = options.transaction;
+  const instanceId = globalThis.crypto?.randomUUID?.() ?? `i${Math.random()}`;
+  let clusterBus;
+  const broadcast = (changes) => {
+    if (clusterBus !== undefined && changes.length > 0) {
+      clusterBus.publish({ changes, origin: instanceId });
+    }
+  };
   const subsFor = (collection) => {
     let set = active.get(collection);
     if (set === undefined) {
@@ -832,52 +940,243 @@ var createSyncEngine = (options = {}) => {
     set.add(name);
   };
   const sideChange = (change, match) => change.op !== "delete" && match !== undefined && !match(change.row) ? { op: "delete", row: change.row } : change;
-  const applyToSubscription = async (subscription, table, change, changeVersion) => {
-    let diff;
+  const EMPTY_DIFF = {
+    added: [],
+    removed: [],
+    changed: []
+  };
+  const subscriptionDiff = async (subscription, table, change) => {
     if (subscription.kind === "graph") {
-      diff = subscription.instance.applyChange(table, change);
-    } else if (subscription.kind === "join") {
+      return subscription.instance.applyChange(table, change);
+    }
+    if (subscription.kind === "join") {
       const js = subscription.join;
       if (table === js.leftTable) {
-        diff = js.op.applyLeft(sideChange(change, js.leftMatch));
-      } else if (table === js.rightTable) {
-        diff = js.op.applyRight(sideChange(change, js.rightMatch));
-      } else {
-        return;
+        return js.op.applyLeft(sideChange(change, js.leftMatch));
       }
-    } else if (subscription.incremental) {
+      if (table === js.rightTable) {
+        return js.op.applyRight(sideChange(change, js.rightMatch));
+      }
+      return EMPTY_DIFF;
+    }
+    if (subscription.kind === "reactive") {
+      return EMPTY_DIFF;
+    }
+    if (subscription.incremental) {
       try {
-        diff = subscription.view.apply(change);
+        return subscription.view.apply(change);
       } catch {
-        diff = subscription.view.reset(await subscription.rehydrate());
+        return subscription.view.reset(await subscription.rehydrate());
       }
-    } else {
-      diff = subscription.view.reset(await subscription.rehydrate());
     }
-    if (!isEmptyViewDiff(diff)) {
-      subscription.onDiff(diff, changeVersion);
+    return subscription.view.reset(await subscription.rehydrate());
+  };
+  const subscriptionsForTable = function* (table) {
+    const names = tableIndex.get(table);
+    if (names === undefined) {
+      return;
+    }
+    for (const name of names) {
+      const set = active.get(name);
+      if (set === undefined) {
+        continue;
+      }
+      yield* set;
     }
   };
-  const applyChange = async (table, change) => {
-    version += 1;
-    changeLog.push({ version, table, change });
+  const mergeViewDiffs = (diffs, key) => {
+    const net = new Map;
+    for (const diff of diffs) {
+      for (const row of diff.removed) {
+        const previous = net.get(key(row));
+        if (previous?.state === "added") {
+          net.delete(key(row));
+        } else {
+          net.set(key(row), { state: "removed", row });
+        }
+      }
+      for (const row of diff.added) {
+        const previous = net.get(key(row));
+        net.set(key(row), {
+          state: previous?.state === "removed" ? "changed" : "added",
+          row
+        });
+      }
+      for (const row of diff.changed) {
+        const previous = net.get(key(row));
+        net.set(key(row), {
+          state: previous?.state === "added" ? "added" : "changed",
+          row
+        });
+      }
+    }
+    const added = [];
+    const changed = [];
+    const removed = [];
+    for (const { state, row } of net.values()) {
+      if (state === "added") {
+        added.push(row);
+      } else if (state === "changed") {
+        changed.push(row);
+      } else {
+        removed.push(row);
+      }
+    }
+    return { added, changed, removed };
+  };
+  const depKey = (table, key) => `${table} ${key}`;
+  const changedKeyFor = (table, change) => readers.get(table)?.key?.(change.row);
+  const makeReadHandle = (ctx, readTables, readKeys, rangeDeps) => {
+    const readerFor = (table) => {
+      const reader = readers.get(table);
+      if (reader === undefined) {
+        throw new Error(`No reader registered for table "${table}" \u2014 register one with engine.registerReader`);
+      }
+      return reader;
+    };
+    return {
+      all: async (table) => {
+        readTables.add(table);
+        return [...await readerFor(table).all(ctx)];
+      },
+      get: async (table, key) => {
+        const reader = readerFor(table);
+        if (reader.get === undefined) {
+          throw new Error(`Reader for table "${table}" has no get(); use db.all() or add get`);
+        }
+        if (reader.key !== undefined) {
+          readKeys.add(depKey(table, key));
+        } else {
+          readTables.add(table);
+        }
+        return await reader.get(key, ctx);
+      },
+      where: async (table, predicate) => {
+        const reader = readerFor(table);
+        const matched = [...await reader.all(ctx)].filter(predicate);
+        if (reader.key !== undefined) {
+          const key = reader.key;
+          rangeDeps.push({
+            table,
+            predicate,
+            keys: new Set(matched.map(key))
+          });
+        } else {
+          readTables.add(table);
+        }
+        return matched;
+      }
+    };
+  };
+  const diffRerun = (sub, rows) => {
+    const next = new Map;
+    for (const row of rows) {
+      next.set(sub.key(row), row);
+    }
+    const added = [];
+    const removed = [];
+    const changed = [];
+    for (const [rowKey, row] of next) {
+      const previous = sub.current.get(rowKey);
+      if (previous === undefined) {
+        added.push(row);
+      } else if (!shallowEqual4(previous, row)) {
+        changed.push(row);
+      }
+    }
+    for (const [rowKey, row] of sub.current) {
+      if (!next.has(rowKey)) {
+        removed.push(row);
+      }
+    }
+    sub.current = next;
+    return { added, removed, changed };
+  };
+  const inRange = (dep, change) => dep.table === change.table && (change.key !== undefined && dep.keys.has(change.key) || dep.predicate(change.row));
+  const isReactiveAffected = (sub, changes) => changes.some((change) => sub.readTables.has(change.table) || change.key !== undefined && sub.readKeys.has(depKey(change.table, change.key)) || sub.rangeDeps.some((dep) => inRange(dep, change)));
+  const reactivePairs = async (changes) => {
+    const pairs = [];
+    for (const sub of reactiveSubs) {
+      if (!isReactiveAffected(sub, changes)) {
+        continue;
+      }
+      const { rows, readTables, readKeys, rangeDeps } = await sub.rerun();
+      sub.readTables = readTables;
+      sub.readKeys = readKeys;
+      sub.rangeDeps = rangeDeps;
+      const diff = diffRerun(sub, rows);
+      if (!isEmptyViewDiff(diff)) {
+        pairs.push([sub, diff]);
+      }
+    }
+    return pairs;
+  };
+  const logChange = (changeVersion, entry) => {
+    changeLog.push(entry);
     if (changeLog.length > changeLogSize) {
       changeLog.shift();
     }
+  };
+  const applyChange = async (table, change, shouldBroadcast = true) => {
+    version += 1;
     const changeVersion = version;
-    const collectionNames = tableIndex.get(table);
-    if (collectionNames === undefined) {
+    logChange(changeVersion, { version: changeVersion, table, change });
+    const emissions = [];
+    for (const subscription of subscriptionsForTable(table)) {
+      const diff = await subscriptionDiff(subscription, table, change);
+      if (!isEmptyViewDiff(diff)) {
+        emissions.push([subscription, diff]);
+      }
+    }
+    emissions.push(...await reactivePairs([
+      { table, key: changedKeyFor(table, change), row: change.row }
+    ]));
+    for (const [subscription, diff] of emissions) {
+      subscription.onDiff(diff, changeVersion);
+    }
+    if (shouldBroadcast) {
+      broadcast([{ table, change }]);
+    }
+  };
+  const applyChangeBatch = async (changes, shouldBroadcast = true) => {
+    if (changes.length === 0) {
       return;
     }
-    for (const name of collectionNames) {
-      const set = active.get(name);
-      if (set === undefined || set.size === 0) {
-        continue;
+    version += 1;
+    const batchVersion = version;
+    const perSubscription = new Map;
+    const reactiveChanges = [];
+    for (const { table, change } of changes) {
+      logChange(batchVersion, { version: batchVersion, table, change });
+      reactiveChanges.push({
+        table,
+        key: changedKeyFor(table, change),
+        row: change.row
+      });
+      for (const subscription of subscriptionsForTable(table)) {
+        const diff = await subscriptionDiff(subscription, table, change);
+        const list = perSubscription.get(subscription);
+        if (list === undefined) {
+          perSubscription.set(subscription, [diff]);
+        } else {
+          list.push(diff);
+        }
       }
-      for (const subscription of set) {
-        await applyToSubscription(subscription, table, change, changeVersion);
+    }
+    const emissions = [];
+    for (const [subscription, diffs] of perSubscription) {
+      const merged = diffs.length === 1 ? diffs[0] : mergeViewDiffs(diffs, subscription.key);
+      if (!isEmptyViewDiff(merged)) {
+        emissions.push([subscription, merged]);
       }
     }
+    emissions.push(...await reactivePairs(reactiveChanges));
+    for (const [subscription, diff] of emissions) {
+      subscription.onDiff(diff, batchVersion);
+    }
+    if (shouldBroadcast) {
+      broadcast(changes);
+    }
   };
   const canResume = (since, incremental) => {
     if (!incremental) {
@@ -933,6 +1232,7 @@ var createSyncEngine = (options = {}) => {
         leftMatch: left.match ? (row) => left.match(row, params, ctx) : undefined,
         rightMatch: right.match ? (row) => right.match(row, params, ctx) : undefined
       },
+      key: definition.key,
       onDiff
     };
     set.add(subscription);
@@ -958,6 +1258,7 @@ var createSyncEngine = (options = {}) => {
       kind: "graph",
       collection,
       instance,
+      key: definition.key,
       onDiff
     };
     set.add(subscription);
@@ -969,6 +1270,49 @@ var createSyncEngine = (options = {}) => {
       }
     };
   };
+  const subscribeReactive = async (collection, definition, params, ctx, onDiff, set) => {
+    if (definition.authorize !== undefined) {
+      const allowed = await definition.authorize(params, ctx);
+      if (!allowed) {
+        throw new UnauthorizedError(`subscribe to collection "${collection}"`);
+      }
+    }
+    const rerun = async () => {
+      const readTables = new Set;
+      const readKeys = new Set;
+      const rangeDeps = [];
+      const db = makeReadHandle(ctx, readTables, readKeys, rangeDeps);
+      const rows = [...await definition.run({ ctx, db, params })];
+      return { rangeDeps, readKeys, readTables, rows };
+    };
+    const first = await rerun();
+    const current = new Map;
+    for (const row of first.rows) {
+      current.set(definition.key(row), row);
+    }
+    const atVersion = version;
+    const subscription = {
+      kind: "reactive",
+      collection,
+      key: definition.key,
+      rerun,
+      current,
+      readTables: first.readTables,
+      readKeys: first.readKeys,
+      rangeDeps: first.rangeDeps,
+      onDiff
+    };
+    set.add(subscription);
+    reactiveSubs.add(subscription);
+    return {
+      initial: first.rows,
+      version: atVersion,
+      unsubscribe: () => {
+        set.delete(subscription);
+        reactiveSubs.delete(subscription);
+      }
+    };
+  };
   return {
     register: (collection) => {
       registry.set(collection.name, collection);
@@ -1003,6 +1347,10 @@ var createSyncEngine = (options = {}) => {
         const graphed = await subscribeGraph(collection, registered, params, ctx, typedOnDiff, subscribeSet);
         return graphed;
       }
+      if (registeredKind === "reactive") {
+        const reactived = await subscribeReactive(collection, registered, params, ctx, typedOnDiff, subscribeSet);
+        return reactived;
+      }
       const definition = registered;
       if (definition.authorize !== undefined) {
         const allowed = await definition.authorize(params, ctx);
@@ -1029,6 +1377,7 @@ var createSyncEngine = (options = {}) => {
         view,
         incremental,
         rehydrate,
+        key,
         onDiff: typedOnDiff
       };
       subscribeSet.add(subscription);
@@ -1069,6 +1418,19 @@ var createSyncEngine = (options = {}) => {
         await source.stop();
       };
     },
+    connectCluster: async (bus) => {
+      const unsubscribe = await bus.subscribe((message) => {
+        if (message.origin === instanceId) {
+          return;
+        }
+        applyChangeBatch(message.changes, false);
+      });
+      clusterBus = bus;
+      return async () => {
+        clusterBus = undefined;
+        await unsubscribe();
+      };
+    },
     subscriptionCount: (collection) => {
       if (collection !== undefined) {
         return active.get(collection)?.size ?? 0;
@@ -1082,6 +1444,15 @@ var createSyncEngine = (options = {}) => {
     registerMutation: (mutation) => {
       mutations.set(mutation.name, mutation);
     },
+    registerWriter: (table, writer) => {
+      writers.set(table, writer);
+    },
+    registerReactive: (query2) => {
+      registry.set(query2.name, query2);
+    },
+    registerReader: (table, reader) => {
+      readers.set(table, reader);
+    },
     runMutation: async (name, args, ctx) => {
       const mutation = mutations.get(name);
       if (mutation === undefined) {
@@ -1093,9 +1464,44 @@ var createSyncEngine = (options = {}) => {
           throw new UnauthorizedError(`run mutation "${name}"`);
         }
       }
-      return mutation.handler(args, ctx, {
-        change: (collection, change) => applyChange(collection, change)
-      });
+      const writerFor = (table) => {
+        const writer = writers.get(table);
+        if (writer === undefined) {
+          throw new Error(`No writer registered for table "${table}" \u2014 register one with engine.registerWriter, or use actions.change`);
+        }
+        return writer;
+      };
+      const runHandler = async (tx) => {
+        const buffered2 = [];
+        const actions = {
+          change: (collection, change) => {
+            buffered2.push({
+              table: collection,
+              change
+            });
+            return Promise.resolve();
+          },
+          insert: async (table, data) => {
+            const row = await writerFor(table).insert(data, ctx, tx);
+            buffered2.push({ table, change: { op: "insert", row } });
+            return row;
+          },
+          update: async (table, data) => {
+            const row = await writerFor(table).update(data, ctx, tx);
+            buffered2.push({ table, change: { op: "update", row } });
+            return row;
+          },
+          delete: async (table, row) => {
+            await writerFor(table).delete(row, ctx, tx);
+            buffered2.push({ table, change: { op: "delete", row } });
+          }
+        };
+        const handlerResult = await mutation.handler(args, ctx, actions);
+        return { buffered: buffered2, result: handlerResult };
+      };
+      const { buffered, result } = runInTransaction !== undefined ? await runInTransaction((tx) => runHandler(tx)) : await runHandler(undefined);
+      await applyChangeBatch(buffered);
+      return result;
     }
   };
 };
@@ -1147,14 +1553,73 @@ var parseFrame = (raw) => {
       args: frame.args
     } : undefined;
   }
+  if (frame.type === "presence-join") {
+    return typeof frame.room === "string" && typeof frame.memberId === "string" ? {
+      type: "presence-join",
+      room: frame.room,
+      memberId: frame.memberId,
+      state: frame.state
+    } : undefined;
+  }
+  if (frame.type === "presence-set") {
+    return typeof frame.room === "string" ? { type: "presence-set", room: frame.room, state: frame.state } : undefined;
+  }
+  if (frame.type === "presence-leave") {
+    return typeof frame.room === "string" ? { type: "presence-leave", room: frame.room } : undefined;
+  }
   return;
 };
 var createSyncConnection = ({
   engine,
   ctx,
-  send
+  send,
+  presence
 }) => {
   const subscriptions = new Map;
+  const presenceRooms = new Map;
+  let pending = [];
+  let pendingVersion;
+  let flushScheduled = false;
+  const flush = () => {
+    if (pending.length === 0) {
+      return;
+    }
+    const diffs = pending;
+    const version = pendingVersion;
+    pending = [];
+    pendingVersion = undefined;
+    if (diffs.length === 1) {
+      const only = diffs[0];
+      send({
+        type: "diff",
+        id: only.id,
+        added: only.added,
+        removed: only.removed,
+        changed: only.changed,
+        version
+      });
+    } else {
+      send({ type: "frame", diffs, version });
+    }
+  };
+  const scheduleFlush = () => {
+    if (flushScheduled) {
+      return;
+    }
+    flushScheduled = true;
+    queueMicrotask(() => {
+      flushScheduled = false;
+      flush();
+    });
+  };
+  const bufferDiff = (diff, diffVersion) => {
+    if (pending.length > 0 && pendingVersion !== diffVersion) {
+      flush();
+    }
+    pending.push(diff);
+    pendingVersion = diffVersion;
+    scheduleFlush();
+  };
   const handle = async (raw) => {
     const frame = parseFrame(raw);
     if (frame === undefined) {
@@ -1164,6 +1629,7 @@ var createSyncConnection = ({
     if (frame.type === "mutate") {
       try {
         const result = await engine.runMutation(frame.name, frame.args, ctx);
+        flush();
         send({ type: "ack", mutationId: frame.mutationId, result });
       } catch (error) {
         send({
@@ -1179,6 +1645,40 @@ var createSyncConnection = ({
       subscriptions.delete(frame.id);
       return;
     }
+    if (frame.type === "presence-join") {
+      if (presence === undefined) {
+        send({ type: "error", message: "Presence is not enabled" });
+        return;
+      }
+      presenceRooms.get(frame.room)?.leave();
+      const handle2 = presence.join(frame.room, frame.memberId, frame.state, (diff) => {
+        send({
+          type: "presence",
+          room: frame.room,
+          joined: diff.joined,
+          updated: diff.updated,
+          left: diff.left
+        });
+      });
+      presenceRooms.set(frame.room, handle2);
+      send({
+        type: "presence",
+        room: frame.room,
+        joined: handle2.members,
+        updated: [],
+        left: []
+      });
+      return;
+    }
+    if (frame.type === "presence-set") {
+      presenceRooms.get(frame.room)?.set(frame.state);
+      return;
+    }
+    if (frame.type === "presence-leave") {
+      presenceRooms.get(frame.room)?.leave();
+      presenceRooms.delete(frame.room);
+      return;
+    }
     if (subscriptions.has(frame.id)) {
       send({
         type: "error",
@@ -1194,14 +1694,12 @@ var createSyncConnection = ({
         ctx,
         since: frame.since,
         onDiff: (diff, diffVersion) => {
-          send({
-            type: "diff",
+          bufferDiff({
             id: frame.id,
             added: diff.added,
             removed: diff.removed,
-            changed: diff.changed,
-            version: diffVersion
-          });
+            changed: diff.changed
+          }, diffVersion);
         }
       });
       subscriptions.set(frame.id, subscription);
@@ -1235,6 +1733,10 @@ var createSyncConnection = ({
       subscription.unsubscribe();
     }
     subscriptions.clear();
+    for (const handle2 of presenceRooms.values()) {
+      handle2.leave();
+    }
+    presenceRooms.clear();
   };
   return { handle, close };
 };
@@ -1250,14 +1752,17 @@ export {
   hydrateRoute,
   fromRowChange,
   filterOp,
+  defineReactiveQuery,
   defineMutation,
   defineJoinCollection,
   defineGraphCollection,
   defineCollection,
   createSyncEngine,
   createSyncConnection,
+  createPresenceHub,
   createPollingChangeSource,
   createMaterializedView,
+  createInMemoryClusterBus,
   createEquiJoin,
   createAggregate,
   chain,
@@ -1265,5 +1770,5 @@ export {
   UnauthorizedError
 };
 
-//# debugId=CDF0007CE81F93F364756E2164756E21
+//# debugId=4ADB152722C87EA464756E2164756E21
 //# sourceMappingURL=index.js.map