@rocicorp/zero 0.25.0 → 0.26.0-canary.0

package/out/replicache/src/patch-operation.js

@@ -0,0 +1,42 @@
+import { assertArray, assertObject, assertString } from "../../shared/src/asserts.js";
+import { assertJSONObject, assertJSONValue } from "../../shared/src/json.js";
+function assertPatchOperations(p) {
+  assertArray(p);
+  for (const item of p) {
+    assertPatchOperation(item);
+  }
+}
+function assertPatchOperation(p) {
+  assertObject(p);
+  switch (p.op) {
+    case "put":
+      assertString(p.key);
+      assertJSONValue(p.value);
+      break;
+    case "update":
+      assertString(p.key);
+      if (p.merge !== void 0) {
+        assertJSONObject(p.merge);
+      }
+      if (p.constrain !== void 0) {
+        assertArray(p.constrain);
+        for (const key of p.constrain) {
+          assertString(key);
+        }
+      }
+      break;
+    case "del":
+      assertString(p.key);
+      break;
+    case "clear":
+      break;
+    default:
+      throw new Error(
+        `unknown patch op \`${p.op}\`, expected one of \`put\`, \`del\`, \`clear\``
+      );
+  }
+}
+export {
+  assertPatchOperations
+};
+//# sourceMappingURL=patch-operation.js.map

package/out/replicache/src/patch-operation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch-operation.js","sources":["../../../../replicache/src/patch-operation.ts"],"sourcesContent":["import {\n  assertArray,\n  assertObject,\n  assertString,\n} from '../../shared/src/asserts.ts';\nimport {\n  type ReadonlyJSONObject,\n  type ReadonlyJSONValue,\n  assertJSONObject,\n  assertJSONValue,\n} from '../../shared/src/json.ts';\n\nexport type PatchOperationInternal =\n  | {\n      readonly op: 'put';\n      readonly key: string;\n      readonly value: ReadonlyJSONValue;\n    }\n  | {\n      readonly op: 'update';\n      readonly key: string;\n      readonly merge?: ReadonlyJSONObject | undefined;\n      readonly constrain?: readonly string[] | undefined;\n    }\n  | {\n      readonly op: 'del';\n      readonly key: string;\n    }\n  | {\n      readonly op: 'clear';\n    };\n\n/**\n * This type describes the patch field in a {@link PullResponse} and it is used\n * to describe how to update the Replicache key-value store.\n */\nexport type PatchOperation =\n  | {\n      readonly op: 'put';\n      readonly key: string;\n      readonly value: ReadonlyJSONValue;\n    }\n  | {\n      readonly op: 'del';\n      readonly key: string;\n    }\n  | {\n      readonly op: 'clear';\n    };\n\nexport function assertPatchOperations(\n  p: unknown,\n): asserts p is PatchOperationInternal[] {\n  assertArray(p);\n  for (const item of p) {\n    assertPatchOperation(item);\n  }\n}\n\nfunction assertPatchOperation(p: unknown): asserts p is PatchOperationInternal {\n  assertObject(p);\n  switch (p.op) {\n    case 'put':\n      assertString(p.key);\n      assertJSONValue(p.value);\n      break;\n    case 'update':\n      assertString(p.key);\n      if (p.merge !== undefined) {\n        assertJSONObject(p.merge);\n      }\n      if (p.constrain !== undefined) {\n        assertArray(p.constrain);\n        for (const key of p.constrain) {\n          assertString(key);\n        }\n      }\n      break;\n    case 'del':\n      assertString(p.key);\n      break;\n    case 'clear':\n      break;\n    default:\n      throw new Error(\n        `unknown patch op \\`${p.op}\\`, expected one of \\`put\\`, \\`del\\`, \\`clear\\``,\n      );\n  }\n}\n"],"names":[],"mappings":";;AAkDO,SAAS,sBACd,GACuC;AACvC,cAAY,CAAC;AACb,aAAW,QAAQ,GAAG;AACpB,yBAAqB,IAAI;AAAA,EAC3B;AACF;AAEA,SAAS,qBAAqB,GAAiD;AAC7E,eAAa,CAAC;AACd,UAAQ,EAAE,IAAA;AAAA,IACR,KAAK;AACH,mBAAa,EAAE,GAAG;AAClB,sBAAgB,EAAE,KAAK;AACvB;AAAA,IACF,KAAK;AACH,mBAAa,EAAE,GAAG;AAClB,UAAI,EAAE,UAAU,QAAW;AACzB,yBAAiB,EAAE,KAAK;AAAA,MAC1B;AACA,UAAI,EAAE,cAAc,QAAW;AAC7B,oBAAY,EAAE,SAAS;AACvB,mBAAW,OAAO,EAAE,WAAW;AAC7B,uBAAa,GAAG;AAAA,QAClB;AAAA,MACF;AACA;AAAA,IACF,KAAK;AACH,mBAAa,EAAE,GAAG;AAClB;AAAA,IACF,KAAK;AACH;AAAA,IACF;AACE,YAAM,IAAI;AAAA,QACR,sBAAsB,EAAE,EAAE;AAAA,MAAA;AAAA,EAC5B;AAEN;"}

package/out/replicache/src/pending-mutations.js

@@ -0,0 +1,16 @@
+import { mustGetHeadHash } from "./dag/store.js";
+import { DEFAULT_HEAD_NAME, localMutationsDD31 } from "./db/commit.js";
+async function pendingMutationsForAPI(dagRead) {
+  const mainHeadHash = await mustGetHeadHash(DEFAULT_HEAD_NAME, dagRead);
+  const pending = await localMutationsDD31(mainHeadHash, dagRead);
+  return pending.map((p) => ({
+    id: p.meta.mutationID,
+    name: p.meta.mutatorName,
+    args: p.meta.mutatorArgsJSON,
+    clientID: p.meta.clientID
+  })).reverse();
+}
+export {
+  pendingMutationsForAPI
+};
+//# sourceMappingURL=pending-mutations.js.map

package/out/replicache/src/pending-mutations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-mutations.js","sources":["../../../../replicache/src/pending-mutations.ts"],"sourcesContent":["import type {ReadonlyJSONValue} from '../../shared/src/json.ts';\nimport {mustGetHeadHash, type Read} from './dag/store.ts';\nimport {DEFAULT_HEAD_NAME, localMutationsDD31} from './db/commit.ts';\nimport type {ClientID} from './sync/ids.ts';\n\nexport type PendingMutation = {\n  readonly name: string;\n  readonly id: number;\n  readonly args: ReadonlyJSONValue;\n  readonly clientID: ClientID;\n};\n\n/**\n * This returns the pending changes with the oldest mutations first.\n */\nexport async function pendingMutationsForAPI(\n  dagRead: Read,\n): Promise<readonly PendingMutation[]> {\n  const mainHeadHash = await mustGetHeadHash(DEFAULT_HEAD_NAME, dagRead);\n  const pending = await localMutationsDD31(mainHeadHash, dagRead);\n  return pending\n    .map(p => ({\n      id: p.meta.mutationID,\n      name: p.meta.mutatorName,\n      args: p.meta.mutatorArgsJSON,\n      clientID: p.meta.clientID,\n    }))\n    .reverse();\n}\n"],"names":[],"mappings":";;AAeA,eAAsB,uBACpB,SACqC;AACrC,QAAM,eAAe,MAAM,gBAAgB,mBAAmB,OAAO;AACrE,QAAM,UAAU,MAAM,mBAAmB,cAAc,OAAO;AAC9D,SAAO,QACJ,IAAI,CAAA,OAAM;AAAA,IACT,IAAI,EAAE,KAAK;AAAA,IACX,MAAM,EAAE,KAAK;AAAA,IACb,MAAM,EAAE,KAAK;AAAA,IACb,UAAU,EAAE,KAAK;AAAA,EAAA,EACjB,EACD,QAAA;AACL;"}

package/out/replicache/src/persist/client-gc.js

@@ -0,0 +1,58 @@
+import { initBgIntervalProcess } from "../bg-interval.js";
+import { addDeletedClients } from "../deleted-clients.js";
+import { withWrite } from "../with-transactions.js";
+import { getClients, setClients } from "./clients.js";
+const CLIENT_MAX_INACTIVE_TIME = 24 * 60 * 60 * 1e3;
+const GC_INTERVAL = 5 * 60 * 1e3;
+let latestGCUpdate;
+function initClientGC(clientID, dagStore, clientMaxInactiveTime, gcInterval, onClientsDeleted, lc, signal) {
+  initBgIntervalProcess(
+    "ClientGC",
+    () => {
+      latestGCUpdate = gcClients(
+        clientID,
+        dagStore,
+        clientMaxInactiveTime,
+        onClientsDeleted
+      );
+      return latestGCUpdate;
+    },
+    () => gcInterval,
+    lc,
+    signal
+  );
+}
+function gcClients(clientID, dagStore, clientMaxInactiveTime, onClientsDeleted) {
+  return withWrite(dagStore, async (dagWrite) => {
+    const now = Date.now();
+    const clients = await getClients(dagWrite);
+    const deletedClients = [];
+    const newClients = /* @__PURE__ */ new Map();
+    for (const [id, client] of clients) {
+      if (id === clientID || now - client.heartbeatTimestampMs <= clientMaxInactiveTime) {
+        newClients.set(id, client);
+      } else {
+        deletedClients.push({
+          clientGroupID: client.clientGroupID,
+          clientID: id
+        });
+      }
+    }
+    if (newClients.size === clients.size) {
+      return clients;
+    }
+    await setClients(newClients, dagWrite);
+    const normalizedDeletedClients = await addDeletedClients(
+      dagWrite,
+      deletedClients
+    );
+    await onClientsDeleted(normalizedDeletedClients);
+    return newClients;
+  });
+}
+export {
+  CLIENT_MAX_INACTIVE_TIME,
+  GC_INTERVAL,
+  initClientGC
+};
+//# sourceMappingURL=client-gc.js.map

package/out/replicache/src/persist/client-gc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-gc.js","sources":["../../../../../replicache/src/persist/client-gc.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {initBgIntervalProcess} from '../bg-interval.ts';\nimport type {Store} from '../dag/store.ts';\nimport {\n  addDeletedClients,\n  type WritableDeletedClients,\n} from '../deleted-clients.ts';\nimport type {ClientID} from '../sync/ids.ts';\nimport {withWrite} from '../with-transactions.ts';\nimport type {Client, OnClientsDeleted} from './clients.ts';\nimport {type ClientMap, getClients, setClients} from './clients.ts';\n\n/**\n * The maximum time a client can be inactive before it is garbage collected.\n * This means that this is the maximum time a tab can be in the background\n * (frozen) and still be able to sync when it comes back to the foreground.\n */\nexport const CLIENT_MAX_INACTIVE_TIME = 24 * 60 * 60 * 1000; // 24 hours\n\n/**\n * How frequently to try to garbage collect clients.\n */\nexport const GC_INTERVAL = 5 * 60 * 1000; // 5 minutes\n\nlet latestGCUpdate: Promise<ClientMap> | undefined;\nexport function getLatestGCUpdate(): Promise<ClientMap> | undefined {\n  return latestGCUpdate;\n}\n\nexport function initClientGC(\n  clientID: ClientID,\n  dagStore: Store,\n  clientMaxInactiveTime: number,\n  gcInterval: number,\n  onClientsDeleted: OnClientsDeleted,\n  lc: LogContext,\n  signal: AbortSignal,\n): void {\n  initBgIntervalProcess(\n    'ClientGC',\n    () => {\n      latestGCUpdate = gcClients(\n        clientID,\n        dagStore,\n        clientMaxInactiveTime,\n        onClientsDeleted,\n      );\n      return latestGCUpdate;\n    },\n    () => gcInterval,\n    lc,\n    signal,\n  );\n}\n\nfunction gcClients(\n  clientID: ClientID,\n  dagStore: Store,\n  clientMaxInactiveTime: number,\n  onClientsDeleted: OnClientsDeleted,\n): Promise<ClientMap> {\n  return withWrite(dagStore, async dagWrite => {\n    const now = Date.now();\n    const clients = await getClients(dagWrite);\n    const deletedClients: WritableDeletedClients = [];\n    const newClients: Map<ClientID, Client> = new Map();\n    for (const [id, client] of clients) {\n      if (\n        id === clientID /* never collect ourself */ ||\n        now - client.heartbeatTimestampMs <= clientMaxInactiveTime\n      ) {\n        newClients.set(id, client);\n      } else {\n        deletedClients.push({\n          clientGroupID: client.clientGroupID,\n          clientID: id,\n        });\n      }\n    }\n\n    if (newClients.size === clients.size) {\n      return clients;\n    }\n    await setClients(newClients, dagWrite);\n    const normalizedDeletedClients = await addDeletedClients(\n      dagWrite,\n      deletedClients,\n    );\n    await onClientsDeleted(normalizedDeletedClients);\n    return newClients;\n  });\n}\n"],"names":[],"mappings":";;;;AAiBO,MAAM,2BAA2B,KAAK,KAAK,KAAK;AAKhD,MAAM,cAAc,IAAI,KAAK;AAEpC,IAAI;AAKG,SAAS,aACd,UACA,UACA,uBACA,YACA,kBACA,IACA,QACM;AACN;AAAA,IACE;AAAA,IACA,MAAM;AACJ,uBAAiB;AAAA,QACf;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MAAA;AAEF,aAAO;AAAA,IACT;AAAA,IACA,MAAM;AAAA,IACN;AAAA,IACA;AAAA,EAAA;AAEJ;AAEA,SAAS,UACP,UACA,UACA,uBACA,kBACoB;AACpB,SAAO,UAAU,UAAU,OAAM,aAAY;AAC3C,UAAM,MAAM,KAAK,IAAA;AACjB,UAAM,UAAU,MAAM,WAAW,QAAQ;AACzC,UAAM,iBAAyC,CAAA;AAC/C,UAAM,iCAAwC,IAAA;AAC9C,eAAW,CAAC,IAAI,MAAM,KAAK,SAAS;AAClC,UACE,OAAO,YACP,MAAM,OAAO,wBAAwB,uBACrC;AACA,mBAAW,IAAI,IAAI,MAAM;AAAA,MAC3B,OAAO;AACL,uBAAe,KAAK;AAAA,UAClB,eAAe,OAAO;AAAA,UACtB,UAAU;AAAA,QAAA,CACX;AAAA,MACH;AAAA,IACF;AAEA,QAAI,WAAW,SAAS,QAAQ,MAAM;AACpC,aAAO;AAAA,IACT;AACA,UAAM,WAAW,YAAY,QAAQ;AACrC,UAAM,2BAA2B,MAAM;AAAA,MACrC;AAAA,MACA;AAAA,IAAA;AAEF,UAAM,iBAAiB,wBAAwB;AAC/C,WAAO;AAAA,EACT,CAAC;AACH;"}

package/out/replicache/src/persist/client-group-gc.js

@@ -0,0 +1,43 @@
+import { initBgIntervalProcess } from "../bg-interval.js";
+import { withWrite } from "../with-transactions.js";
+import { getClientGroups, clientGroupHasPendingMutations, setClientGroups } from "./client-groups.js";
+import { getClients } from "./clients.js";
+const GC_INTERVAL_MS = 5 * 60 * 1e3;
+let latestGCUpdate;
+function initClientGroupGC(dagStore, enableMutationRecovery, lc, signal) {
+  initBgIntervalProcess(
+    "ClientGroupGC",
+    () => {
+      latestGCUpdate = gcClientGroups(dagStore, enableMutationRecovery);
+      return latestGCUpdate;
+    },
+    () => GC_INTERVAL_MS,
+    lc,
+    signal
+  );
+}
+function gcClientGroups(dagStore, enableMutationRecovery) {
+  return withWrite(dagStore, async (tx) => {
+    const clients = await getClients(tx);
+    const clientGroupIDs = /* @__PURE__ */ new Set();
+    for (const client of clients.values()) {
+      clientGroupIDs.add(client.clientGroupID);
+    }
+    const clientGroups = /* @__PURE__ */ new Map();
+    const removeClientGroups = /* @__PURE__ */ new Set();
+    for (const [clientGroupID, clientGroup] of await getClientGroups(tx)) {
+      if (clientGroupIDs.has(clientGroupID) || enableMutationRecovery && clientGroupHasPendingMutations(clientGroup)) {
+        clientGroups.set(clientGroupID, clientGroup);
+      } else {
+        removeClientGroups.add(clientGroupID);
+      }
+    }
+    await setClientGroups(clientGroups, tx);
+    return clientGroups;
+  });
+}
+export {
+  gcClientGroups,
+  initClientGroupGC
+};
+//# sourceMappingURL=client-group-gc.js.map

package/out/replicache/src/persist/client-group-gc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-group-gc.js","sources":["../../../../../replicache/src/persist/client-group-gc.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {initBgIntervalProcess} from '../bg-interval.ts';\nimport type {Store} from '../dag/store.ts';\nimport type {ClientGroupID} from '../sync/ids.ts';\nimport {withWrite} from '../with-transactions.ts';\nimport {\n  clientGroupHasPendingMutations,\n  getClientGroups,\n  setClientGroups,\n  type ClientGroupMap,\n} from './client-groups.ts';\nimport {getClients} from './clients.ts';\n\nconst GC_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes\n\nlet latestGCUpdate: Promise<ClientGroupMap> | undefined;\nexport function getLatestGCUpdate(): Promise<ClientGroupMap> | undefined {\n  return latestGCUpdate;\n}\n\nexport function initClientGroupGC(\n  dagStore: Store,\n  enableMutationRecovery: boolean,\n  lc: LogContext,\n  signal: AbortSignal,\n): void {\n  initBgIntervalProcess(\n    'ClientGroupGC',\n    () => {\n      latestGCUpdate = gcClientGroups(dagStore, enableMutationRecovery);\n      return latestGCUpdate;\n    },\n    () => GC_INTERVAL_MS,\n    lc,\n    signal,\n  );\n}\n\n/**\n * This removes client groups that have no clients and no pending mutations.\n * If {@linkcode enableMutationRecovery} is true, it will keep client groups with\n * pending mutations. If it is false, it will remove client groups even when they\n * have pending mutations.\n */\nexport function gcClientGroups(\n  dagStore: Store,\n  enableMutationRecovery: boolean,\n): Promise<ClientGroupMap> {\n  return withWrite(dagStore, async tx => {\n    const clients = await getClients(tx);\n    const clientGroupIDs = new Set();\n    for (const client of clients.values()) {\n      clientGroupIDs.add(client.clientGroupID);\n    }\n    const clientGroups = new Map();\n    const removeClientGroups: Set<ClientGroupID> = new Set();\n    for (const [clientGroupID, clientGroup] of await getClientGroups(tx)) {\n      if (\n        clientGroupIDs.has(clientGroupID) ||\n        (enableMutationRecovery && clientGroupHasPendingMutations(clientGroup))\n      ) {\n        clientGroups.set(clientGroupID, clientGroup);\n      } else {\n        removeClientGroups.add(clientGroupID);\n      }\n    }\n    await setClientGroups(clientGroups, tx);\n    // Client group GC doesn't delete individual clients, so we don't call onClientsDeleted\n    return clientGroups;\n  });\n}\n"],"names":[],"mappings":";;;;AAaA,MAAM,iBAAiB,IAAI,KAAK;AAEhC,IAAI;AAKG,SAAS,kBACd,UACA,wBACA,IACA,QACM;AACN;AAAA,IACE;AAAA,IACA,MAAM;AACJ,uBAAiB,eAAe,UAAU,sBAAsB;AAChE,aAAO;AAAA,IACT;AAAA,IACA,MAAM;AAAA,IACN;AAAA,IACA;AAAA,EAAA;AAEJ;AAQO,SAAS,eACd,UACA,wBACyB;AACzB,SAAO,UAAU,UAAU,OAAM,OAAM;AACrC,UAAM,UAAU,MAAM,WAAW,EAAE;AACnC,UAAM,qCAAqB,IAAA;AAC3B,eAAW,UAAU,QAAQ,UAAU;AACrC,qBAAe,IAAI,OAAO,aAAa;AAAA,IACzC;AACA,UAAM,mCAAmB,IAAA;AACzB,UAAM,yCAA6C,IAAA;AACnD,eAAW,CAAC,eAAe,WAAW,KAAK,MAAM,gBAAgB,EAAE,GAAG;AACpE,UACE,eAAe,IAAI,aAAa,KAC/B,0BAA0B,+BAA+B,WAAW,GACrE;AACA,qBAAa,IAAI,eAAe,WAAW;AAAA,MAC7C,OAAO;AACL,2BAAmB,IAAI,aAAa;AAAA,MACtC;AAAA,IACF;AACA,UAAM,gBAAgB,cAAc,EAAE;AAEtC,WAAO;AAAA,EACT,CAAC;AACH;"}

package/out/replicache/src/persist/client-groups.js

@@ -0,0 +1,184 @@
+import { assert, assertObject } from "../../../shared/src/asserts.js";
+import { readonlyObject, readonlyRecord, readonlyArray, assert as assert$1 } from "../../../shared/src/valita.js";
+import { toRefs } from "../dag/chunk.js";
+import { deepFreeze } from "../frozen-json.js";
+import { hashSchema } from "../hash.js";
+import { indexDefinitionsSchema, indexDefinitionsEqual } from "../index-defs.js";
+import { boolean, record, number, string } from "@badrap/valita";
+const clientGroupSchema = readonlyObject({
+  /**
+   * The hash of the commit in the perdag last persisted to this client group.
+   * Should only be updated by clients assigned to this client group.
+   */
+  headHash: hashSchema,
+  /**
+   * Set of mutator names common to all clients assigned to this client group.
+   */
+  mutatorNames: readonlyArray(string()),
+  /**
+   * Index definitions common to all clients assigned to this client group.
+   */
+  indexes: indexDefinitionsSchema,
+  /**
+   * The highest mutation ID of every client assigned to this client group.
+   * Should only be updated by clients assigned to this client group. Read by
+   * other clients to determine if there are unacknowledged pending mutations
+   * for them to try to recover. This is redundant with information in the
+   * commit graph at `headHash`, but allows other clients to determine if there
+   * are unacknowledged pending mutations without having to load the commit
+   * graph.
+   */
+  mutationIDs: readonlyRecord(number()),
+  /**
+   * The highest lastMutationID received from the server for every client
+   * assigned to this client group.
+   *
+   * Should be updated by the clients assigned to this client group whenever
+   * they persist to this client group. Read by other clients to determine if
+   * there are unacknowledged pending mutations for them to recover and
+   * *updated* by other clients upon successfully recovering pending mutations
+   * to avoid redundant pushes of pending mutations.
+   *
+   * Note: This will be the same as the `lastMutationIDs` of the base snapshot
+   * of the client group's commit graph when written by clients assigned to this
+   * client group.  However, when written by another client recovering mutations
+   * it may be different because the other client does not update the commit
+   * graph.
+   */
+  lastServerAckdMutationIDs: record(number()),
+  /**
+   * If the server deletes this client group it can signal that the client group
+   * was deleted. If that happens we mark this client group as disabled so that
+   * we do not use it again when creating new clients.
+   */
+  disabled: boolean()
+});
+const CLIENT_GROUPS_HEAD_NAME = "client-groups";
+function assertClientGroup(value) {
+  assert$1(value, clientGroupSchema);
+}
+function chunkDataToClientGroupMap(chunkData) {
+  assertObject(chunkData);
+  const clientGroups = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(chunkData)) {
+    if (value !== void 0) {
+      assertClientGroup(value);
+      clientGroups.set(key, value);
+    }
+  }
+  return clientGroups;
+}
+function clientGroupMapToChunkData(clientGroups, dagWrite) {
+  const chunkData = {};
+  for (const [clientGroupID, clientGroup] of clientGroups.entries()) {
+    dagWrite.assertValidHash(clientGroup.headHash);
+    chunkData[clientGroupID] = {
+      ...clientGroup,
+      mutatorNames: [...clientGroup.mutatorNames.values()]
+    };
+  }
+  return deepFreeze(chunkData);
+}
+async function getClientGroupsAtHash(hash, dagRead) {
+  const chunk = await dagRead.getChunk(hash);
+  return chunkDataToClientGroupMap(chunk?.data);
+}
+async function getClientGroups(dagRead) {
+  const hash = await dagRead.getHead(CLIENT_GROUPS_HEAD_NAME);
+  if (!hash) {
+    return /* @__PURE__ */ new Map();
+  }
+  return getClientGroupsAtHash(hash, dagRead);
+}
+async function setClientGroups(clientGroups, dagWrite) {
+  const currClientGroups = await getClientGroups(dagWrite);
+  for (const [clientGroupID, clientGroup] of clientGroups) {
+    const currClientGroup = currClientGroups.get(clientGroupID);
+    validateClientGroupUpdate(clientGroup, currClientGroup);
+  }
+  return setValidatedClientGroups(clientGroups, dagWrite);
+}
+async function setClientGroup(clientGroupID, clientGroup, dagWrite) {
+  const currClientGroups = await getClientGroups(dagWrite);
+  const currClientGroup = currClientGroups.get(clientGroupID);
+  validateClientGroupUpdate(clientGroup, currClientGroup);
+  const newClientGroups = new Map(currClientGroups);
+  newClientGroups.set(clientGroupID, clientGroup);
+  return setValidatedClientGroups(newClientGroups, dagWrite);
+}
+function validateClientGroupUpdate(clientGroup, currClientGroup) {
+  const mutatorNamesSet = new Set(clientGroup.mutatorNames);
+  assert(
+    mutatorNamesSet.size === clientGroup.mutatorNames.length,
+    "A client group's mutatorNames must be a set."
+  );
+  if (currClientGroup !== void 0) {
+    assert(
+      indexDefinitionsEqual(currClientGroup.indexes, clientGroup.indexes),
+      "A client group's index definitions must never change."
+    );
+    assert(
+      mutatorNamesEqual(mutatorNamesSet, currClientGroup.mutatorNames),
+      "A client group's mutatorNames must never change."
+    );
+  }
+}
+async function setValidatedClientGroups(clientGroups, dagWrite) {
+  const chunkData = clientGroupMapToChunkData(clientGroups, dagWrite);
+  const refs = /* @__PURE__ */ new Set();
+  for (const clientGroup of clientGroups.values()) {
+    refs.add(clientGroup.headHash);
+  }
+  const chunk = dagWrite.createChunk(chunkData, toRefs(refs));
+  await dagWrite.putChunk(chunk);
+  await dagWrite.setHead(CLIENT_GROUPS_HEAD_NAME, chunk.hash);
+  return clientGroups;
+}
+function mutatorNamesEqual(mutatorNamesSet, mutatorNames) {
+  if (mutatorNames.length !== mutatorNamesSet.size) {
+    return false;
+  }
+  for (const mutatorName of mutatorNames) {
+    if (!mutatorNamesSet.has(mutatorName)) {
+      return false;
+    }
+  }
+  return true;
+}
+async function getClientGroup(id, dagRead) {
+  const clientGroups = await getClientGroups(dagRead);
+  return clientGroups.get(id);
+}
+function clientGroupHasPendingMutations(clientGroup) {
+  for (const [clientID, mutationID] of Object.entries(
+    clientGroup.mutationIDs
+  )) {
+    const lastServerAckdMutationID = clientGroup.lastServerAckdMutationIDs[clientID];
+    if (lastServerAckdMutationID === void 0 && mutationID !== 0 || lastServerAckdMutationID < mutationID) {
+      return true;
+    }
+  }
+  return false;
+}
+async function disableClientGroup(clientGroupID, dagWrite) {
+  const clientGroup = await getClientGroup(clientGroupID, dagWrite);
+  if (!clientGroup) {
+    return;
+  }
+  const disabledClientGroup = {
+    ...clientGroup,
+    disabled: true
+  };
+  await setClientGroup(clientGroupID, disabledClientGroup, dagWrite);
+}
+export {
+  CLIENT_GROUPS_HEAD_NAME,
+  clientGroupHasPendingMutations,
+  disableClientGroup,
+  getClientGroup,
+  getClientGroups,
+  mutatorNamesEqual,
+  setClientGroup,
+  setClientGroups
+};
+//# sourceMappingURL=client-groups.js.map

package/out/replicache/src/persist/client-groups.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-groups.js","sources":["../../../../../replicache/src/persist/client-groups.ts"],"sourcesContent":["import {assert, assertObject} from '../../../shared/src/asserts.ts';\nimport * as valita from '../../../shared/src/valita.ts';\nimport {toRefs} from '../dag/chunk.ts';\nimport type {Read, Write} from '../dag/store.ts';\nimport {deepFreeze, type FrozenJSONValue} from '../frozen-json.ts';\nimport {type Hash, hashSchema} from '../hash.ts';\nimport {indexDefinitionsEqual, indexDefinitionsSchema} from '../index-defs.ts';\nimport type {ClientGroupID} from '../sync/ids.ts';\n\nexport type ClientGroupMap = ReadonlyMap<ClientGroupID, ClientGroup>;\n\nconst clientGroupSchema = valita.readonlyObject({\n  /**\n   * The hash of the commit in the perdag last persisted to this client group.\n   * Should only be updated by clients assigned to this client group.\n   */\n  headHash: hashSchema,\n\n  /**\n   * Set of mutator names common to all clients assigned to this client group.\n   */\n  mutatorNames: valita.readonlyArray(valita.string()),\n\n  /**\n   * Index definitions common to all clients assigned to this client group.\n   */\n  indexes: indexDefinitionsSchema,\n\n  /**\n   * The highest mutation ID of every client assigned to this client group.\n   * Should only be updated by clients assigned to this client group. Read by\n   * other clients to determine if there are unacknowledged pending mutations\n   * for them to try to recover. This is redundant with information in the\n   * commit graph at `headHash`, but allows other clients to determine if there\n   * are unacknowledged pending mutations without having to load the commit\n   * graph.\n   */\n  mutationIDs: valita.readonlyRecord(valita.number()),\n\n  /**\n   * The highest lastMutationID received from the server for every client\n   * assigned to this client group.\n   *\n   * Should be updated by the clients assigned to this client group whenever\n   * they persist to this client group. Read by other clients to determine if\n   * there are unacknowledged pending mutations for them to recover and\n   * *updated* by other clients upon successfully recovering pending mutations\n   * to avoid redundant pushes of pending mutations.\n   *\n   * Note: This will be the same as the `lastMutationIDs` of the base snapshot\n   * of the client group's commit graph when written by clients assigned to this\n   * client group.  However, when written by another client recovering mutations\n   * it may be different because the other client does not update the commit\n   * graph.\n   */\n  lastServerAckdMutationIDs: valita.record(valita.number()),\n\n  /**\n   * If the server deletes this client group it can signal that the client group\n   * was deleted. If that happens we mark this client group as disabled so that\n   * we do not use it again when creating new clients.\n   */\n  disabled: valita.boolean(),\n});\n\nexport type ClientGroup = valita.Infer<typeof clientGroupSchema>;\n\nexport const CLIENT_GROUPS_HEAD_NAME = 'client-groups';\n\nfunction assertClientGroup(value: unknown): asserts value is ClientGroup {\n  valita.assert(value, clientGroupSchema);\n}\n\nfunction chunkDataToClientGroupMap(chunkData: unknown): ClientGroupMap {\n  assertObject(chunkData);\n  const clientGroups = new Map<ClientGroupID, ClientGroup>();\n  for (const [key, value] of Object.entries(chunkData)) {\n    if (value !== undefined) {\n      assertClientGroup(value);\n      clientGroups.set(key, value);\n    }\n  }\n  return clientGroups;\n}\n\nfunction clientGroupMapToChunkData(\n  clientGroups: ClientGroupMap,\n  dagWrite: Write,\n): FrozenJSONValue {\n  const chunkData: {[id: ClientGroupID]: ClientGroup} = {};\n  for (const [clientGroupID, clientGroup] of clientGroups.entries()) {\n    dagWrite.assertValidHash(clientGroup.headHash);\n    chunkData[clientGroupID] = {\n      ...clientGroup,\n      mutatorNames: [...clientGroup.mutatorNames.values()],\n    };\n  }\n  return deepFreeze(chunkData);\n}\n\nasync function getClientGroupsAtHash(\n  hash: Hash,\n  dagRead: Read,\n): Promise<ClientGroupMap> {\n  const chunk = await dagRead.getChunk(hash);\n  return chunkDataToClientGroupMap(chunk?.data);\n}\n\nexport async function getClientGroups(dagRead: Read): Promise<ClientGroupMap> {\n  const hash = await dagRead.getHead(CLIENT_GROUPS_HEAD_NAME);\n  if (!hash) {\n    return new Map();\n  }\n  return getClientGroupsAtHash(hash, dagRead);\n}\n\nexport async function setClientGroups(\n  clientGroups: ClientGroupMap,\n  dagWrite: Write,\n): Promise<ClientGroupMap> {\n  const currClientGroups = await getClientGroups(dagWrite);\n  for (const [clientGroupID, clientGroup] of clientGroups) {\n    const currClientGroup = currClientGroups.get(clientGroupID);\n    validateClientGroupUpdate(clientGroup, currClientGroup);\n  }\n  return setValidatedClientGroups(clientGroups, dagWrite);\n}\n\nexport async function setClientGroup(\n  clientGroupID: ClientGroupID,\n  clientGroup: ClientGroup,\n  dagWrite: Write,\n): Promise<ClientGroupMap> {\n  const currClientGroups = await getClientGroups(dagWrite);\n  const currClientGroup = currClientGroups.get(clientGroupID);\n  validateClientGroupUpdate(clientGroup, currClientGroup);\n  const newClientGroups = new Map(currClientGroups);\n  newClientGroups.set(clientGroupID, clientGroup);\n  return setValidatedClientGroups(newClientGroups, dagWrite);\n}\n\nexport async function deleteClientGroup(\n  clientGroupID: ClientGroupID,\n  dagWrite: Write,\n): Promise<ClientGroupMap> {\n  const currClientGroups = await getClientGroups(dagWrite);\n  if (!currClientGroups.has(clientGroupID)) {\n    return currClientGroups;\n  }\n  const newClientGroups = new Map(currClientGroups.entries());\n  newClientGroups.delete(clientGroupID);\n  return setValidatedClientGroups(newClientGroups, dagWrite);\n}\n\nfunction validateClientGroupUpdate(\n  clientGroup: ClientGroup,\n  currClientGroup: ClientGroup | undefined,\n) {\n  const mutatorNamesSet = new Set(clientGroup.mutatorNames);\n  assert(\n    mutatorNamesSet.size === clientGroup.mutatorNames.length,\n    \"A client group's mutatorNames must be a set.\",\n  );\n  if (currClientGroup !== undefined) {\n    assert(\n      indexDefinitionsEqual(currClientGroup.indexes, clientGroup.indexes),\n      \"A client group's index definitions must never change.\",\n    );\n    assert(\n      mutatorNamesEqual(mutatorNamesSet, currClientGroup.mutatorNames),\n      \"A client group's mutatorNames must never change.\",\n    );\n  }\n}\n\nasync function setValidatedClientGroups(\n  clientGroups: ClientGroupMap,\n  dagWrite: Write,\n): Promise<ClientGroupMap> {\n  const chunkData = clientGroupMapToChunkData(clientGroups, dagWrite);\n  const refs: Set<Hash> = new Set();\n  for (const clientGroup of clientGroups.values()) {\n    refs.add(clientGroup.headHash);\n  }\n  const chunk = dagWrite.createChunk(chunkData, toRefs(refs));\n  await dagWrite.putChunk(chunk);\n  await dagWrite.setHead(CLIENT_GROUPS_HEAD_NAME, chunk.hash);\n  return clientGroups;\n}\n\nexport function mutatorNamesEqual(\n  mutatorNamesSet: ReadonlySet<string>,\n  mutatorNames: readonly string[],\n): boolean {\n  if (mutatorNames.length !== mutatorNamesSet.size) {\n    return false;\n  }\n  for (const mutatorName of mutatorNames) {\n    if (!mutatorNamesSet.has(mutatorName)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport async function getClientGroup(\n  id: ClientGroupID,\n  dagRead: Read,\n): Promise<ClientGroup | undefined> {\n  const clientGroups = await getClientGroups(dagRead);\n  return clientGroups.get(id);\n}\n\nexport function clientGroupHasPendingMutations(clientGroup: ClientGroup) {\n  for (const [clientID, mutationID] of Object.entries(\n    clientGroup.mutationIDs,\n  )) {\n    const lastServerAckdMutationID =\n      clientGroup.lastServerAckdMutationIDs[clientID];\n    if (\n      (lastServerAckdMutationID === undefined && mutationID !== 0) ||\n      lastServerAckdMutationID < mutationID\n    ) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Marks a client group as disabled. This can happen if the server deletes the\n * client group (servers should not delete clients or client groups but it often\n * happens in practice when developing).\n *\n * A disabled client group prevents pulls and pushes from happening.\n */\nexport async function disableClientGroup(\n  clientGroupID: string,\n  dagWrite: Write,\n): Promise<void> {\n  const clientGroup = await getClientGroup(clientGroupID, dagWrite);\n  if (!clientGroup) {\n    // No client group matching in the database, so nothing to do.\n    return;\n  }\n  const disabledClientGroup = {\n    ...clientGroup,\n    disabled: true,\n  };\n  await setClientGroup(clientGroupID, disabledClientGroup, dagWrite);\n}\n"],"names":["valita.readonlyObject","valita.readonlyArray","valita.string","valita.readonlyRecord","valita.number","valita.record","valita.boolean","valita.assert"],"mappings":"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"}

package/out/replicache/src/persist/clients.d.ts

@@ -2,9 +2,10 @@ import type { LogContext } from '@rocicorp/logger';
 import type { Enum } from '../../../shared/src/enum.ts';
 import * as valita from '../../../shared/src/valita.ts';
 import type { Read, Store, Write } from '../dag/store.ts';
-import { Commit, type SnapshotMetaDD31 } from '../db/commit.ts';
+import type { Commit } from '../db/commit.ts';
+import { type SnapshotMetaDD31 } from '../db/commit.ts';
 import type { DeletedClients } from '../deleted-clients.ts';
-import * as FormatVersion from '../format-version-enum.ts';
+import type * as FormatVersion from '../format-version-enum.ts';
 import { type Hash } from '../hash.ts';
 import { type IndexDefinitions } from '../index-defs.ts';
 import { type ClientGroupID, type ClientID } from '../sync/ids.ts';

package/out/replicache/src/persist/clients.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clients.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/persist/clients.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,6BAA6B,CAAC;AAEtD,OAAO,KAAK,MAAM,MAAM,+BAA+B,CAAC;AAKxD,OAAO,KAAK,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAC,MAAM,iBAAiB,CAAC;AACxD,OAAO,EAEL,MAAM,EAEN,KAAK,gBAAgB,EAOtB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAC1D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,EAAC,KAAK,IAAI,EAAa,MAAM,YAAY,CAAC;AACjD,OAAO,EAAC,KAAK,gBAAgB,EAAwB,MAAM,kBAAkB,CAAC;AAC9E,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,QAAQ,EAEd,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,KAAK,WAAW,EAKjB,MAAM,oBAAoB,CAAC;AAG5B,KAAK,aAAa,GAAG,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC;AAEhD,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,CAAC,CAAC;AAEnE,QAAA,MAAM,cAAc;;;IAKlB;;;OAGG;;IAGH;;;OAGG;;cAEH,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE3D,QAAA,MAAM,cAAc;;IAGlB;;;;;;;;;;;OAWG;;IAGH;;;OAGG;;IAGH;;;OAGG;;cAEH,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAE3D,MAAM,MAAM,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAMzC,eAAO,MAAM,iBAAiB,YAAY,CAAC;AAQ3C,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,QAAQ,CAExE;AAqCD,wBAAsB,UAAU,CAAC,OAAO,EAAE,IAAI,GAAG,OAAO,CAAC,SAAS,CAAC,CAGlE;AAaD;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,IAAI,SAA8B;IAClC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;gBACR,EAAE,EAAE,QAAQ;CAIzB;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,QAAQ,EACZ,OAAO,EAAE,IAAI,GACZ,OAAO,CAAC,IAAI,CAAC,CAIf;AAED,wBAAsB,cAAc,CAClC,EAAE,EAAE,QAAQ,EACZ,OAAO,EAAE,IAAI,GACZ,OAAO,CAAC,OAAO,CAAC,CAElB;AAED,wBAAsB,SAAS,CAC7B,EAAE,EAAE,QAAQ,EACZ,OAAO,EAAE,IAAI,GACZ,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAG7B;AAED,wBAAsB,aAAa,CACjC,EAAE,EAAE,QAAQ,EACZ,OAAO,EAAE,IAAI,GACZ,OAAO,CAAC,MAAM,CAAC,CAMjB;AAED,KAAK,kBAAkB,GAAG;IACxB,MAAM,EAAE,QAAQ;IAChB,IAAI,EAAE,IAAI;IACV,SAAS,EAAE,SAAS;IACpB,cAAc,EAAE,OAAO;CACxB,CAAC;AAEF,wBAAgB,YAAY,CAC1B,WAAW,EAAE,QAAQ,EACrB,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,KAAK,EACb,YAAY,EAAE,MAAM,EAAE,EACtB,OAAO,EAAE,gBAAgB,EACzB,aAAa,EAAE,aAAa,EAC5B,wBAAwB,EAAE,OAAO,GAChC,OAAO,CAAC,kBAAkB,CAAC,CAuJ7B;AAWD,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAC/C,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAChD,eAAO,MAAM,8BAA8B,IAAI,CAAC;AAEhD,MAAM,MAAM,wBAAwB,GAChC;IACE,IAAI,EAAE,OAAO,6BAA6B,CAAC;CAC5C,GACD;IACE,IAAI,EAAE,OAAO,8BAA8B,CAAC;IAC5C,QAAQ,EAAE,MAAM,CAAC,gBAAgB,CAAC,CAAC;CACpC,GACD;IACE,IAAI,EAAE,OAAO,8BAA8B,CAAC;IAC5C,aAAa,EAAE,aAAa,CAAC;IAC7B,QAAQ,EAAE,IAAI,CAAC;CAChB,CAAC;AAEN,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,IAAI,EACb,YAAY,EAAE,MAAM,EAAE,EACtB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,wBAAwB,CAAC,CA4CnC;AAsBD,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,IAAI,GACT,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAMlC;AAED,wBAAsB,yBAAyB,CAC7C,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,IAAI,GACT,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAGpC;AAED;;;GAGG;AACH,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,KAAK,GACd,OAAO,CAAC,IAAI,CAAC,CAIf;AAED;;;GAGG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,SAAS,EAClB,QAAQ,EAAE,KAAK,GACd,OAAO,CAAC,IAAI,CAAC,CAMf;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAC7B,cAAc,EAAE,cAAc,KAC3B,OAAO,CAAC,IAAI,CAAC,CAAC"}
+{"version":3,"file":"clients.d.ts","sourceRoot":"","sources":["../../../../../replicache/src/persist/clients.ts"],"names":[],"mappings":"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"}