@rocicorp/zero 0.26.1-canary.9 → 0.26.2-canary.1

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

@@ -1,58 +1,43 @@
 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;
+import { addDeletedClients } from "../deleted-clients.js";
+//#region ../replicache/src/persist/client-gc.ts
+/**
+* The maximum time a client can be inactive before it is garbage collected.
+* This means that this is the maximum time a tab can be in the background
+* (frozen) and still be able to sync when it comes back to the foreground.
+*/
+var CLIENT_MAX_INACTIVE_TIME = 1440 * 60 * 1e3;
+/**
+* How frequently to try to garbage collect clients.
+*/
+var GC_INTERVAL = 300 * 1e3;
+var latestGCUpdate;
 function initClientGC(clientID, dagStore, clientMaxInactiveTime, gcInterval, onClientsDeleted, lc, signal) {
-  initBgIntervalProcess(
-    "ClientGC",
-    () => {
-      latestGCUpdate = gcClients(
-        clientID,
-        dagStore,
-        clientMaxInactiveTime,
-        onClientsDeleted
-      );
-      return latestGCUpdate;
-    },
-    () => gcInterval,
-    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;
-  });
+	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);
+		await onClientsDeleted(await addDeletedClients(dagWrite, deletedClients));
+		return newClients;
+	});
 }
-export {
-  CLIENT_MAX_INACTIVE_TIME,
-  GC_INTERVAL,
-  initClientGC
-};
-//# sourceMappingURL=client-gc.js.map
+//#endregion
+export { CLIENT_MAX_INACTIVE_TIME, GC_INTERVAL, initClientGC };
+
+//# sourceMappingURL=client-gc.js.map

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

@@ -1 +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;"}
+{"version":3,"file":"client-gc.js","names":[],"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"],"mappings":";;;;;;;;;;AAiBA,IAAa,2BAA2B,OAAU,KAAK;;;;AAKvD,IAAa,cAAc,MAAS;AAEpC,IAAI;AAKJ,SAAgB,aACd,UACA,UACA,uBACA,YACA,kBACA,IACA,QACM;AACN,uBACE,kBACM;AACJ,mBAAiB,UACf,UACA,UACA,uBACA,iBACD;AACD,SAAO;UAEH,YACN,IACA,OACD;;AAGH,SAAS,UACP,UACA,UACA,uBACA,kBACoB;AACpB,QAAO,UAAU,UAAU,OAAM,aAAY;EAC3C,MAAM,MAAM,KAAK,KAAK;EACtB,MAAM,UAAU,MAAM,WAAW,SAAS;EAC1C,MAAM,iBAAyC,EAAE;EACjD,MAAM,6BAAoC,IAAI,KAAK;AACnD,OAAK,MAAM,CAAC,IAAI,WAAW,QACzB,KACE,OAAO,YACP,MAAM,OAAO,wBAAwB,sBAErC,YAAW,IAAI,IAAI,OAAO;MAE1B,gBAAe,KAAK;GAClB,eAAe,OAAO;GACtB,UAAU;GACX,CAAC;AAIN,MAAI,WAAW,SAAS,QAAQ,KAC9B,QAAO;AAET,QAAM,WAAW,YAAY,SAAS;AAKtC,QAAM,iBAJ2B,MAAM,kBACrC,UACA,eACD,CAC+C;AAChD,SAAO;GACP"}

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

@@ -1,43 +1,36 @@
 import { initBgIntervalProcess } from "../bg-interval.js";
 import { withWrite } from "../with-transactions.js";
-import { getClientGroups, clientGroupHasPendingMutations, setClientGroups } from "./client-groups.js";
+import { clientGroupHasPendingMutations, getClientGroups, setClientGroups } from "./client-groups.js";
 import { getClients } from "./clients.js";
-const GC_INTERVAL_MS = 5 * 60 * 1e3;
-let latestGCUpdate;
+//#region ../replicache/src/persist/client-group-gc.ts
+var GC_INTERVAL_MS = 300 * 1e3;
+var latestGCUpdate;
 function initClientGroupGC(dagStore, enableMutationRecovery, lc, signal) {
-  initBgIntervalProcess(
-    "ClientGroupGC",
-    () => {
-      latestGCUpdate = gcClientGroups(dagStore, enableMutationRecovery);
-      return latestGCUpdate;
-    },
-    () => GC_INTERVAL_MS,
-    lc,
-    signal
-  );
+	initBgIntervalProcess("ClientGroupGC", () => {
+		latestGCUpdate = gcClientGroups(dagStore, enableMutationRecovery);
+		return latestGCUpdate;
+	}, () => GC_INTERVAL_MS, lc, signal);
 }
+/**
+* This removes client groups that have no clients and no pending mutations.
+* If {@linkcode enableMutationRecovery} is true, it will keep client groups with
+* pending mutations. If it is false, it will remove client groups even when they
+* have pending mutations.
+*/
 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;
-  });
+	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
+//#endregion
+export { initClientGroupGC };
+
+//# sourceMappingURL=client-group-gc.js.map

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

@@ -1 +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;"}
+{"version":3,"file":"client-group-gc.js","names":[],"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"],"mappings":";;;;;AAaA,IAAM,iBAAiB,MAAS;AAEhC,IAAI;AAKJ,SAAgB,kBACd,UACA,wBACA,IACA,QACM;AACN,uBACE,uBACM;AACJ,mBAAiB,eAAe,UAAU,uBAAuB;AACjE,SAAO;UAEH,gBACN,IACA,OACD;;;;;;;;AASH,SAAgB,eACd,UACA,wBACyB;AACzB,QAAO,UAAU,UAAU,OAAM,OAAM;EACrC,MAAM,UAAU,MAAM,WAAW,GAAG;EACpC,MAAM,iCAAiB,IAAI,KAAK;AAChC,OAAK,MAAM,UAAU,QAAQ,QAAQ,CACnC,gBAAe,IAAI,OAAO,cAAc;EAE1C,MAAM,+BAAe,IAAI,KAAK;EAC9B,MAAM,qCAAyC,IAAI,KAAK;AACxD,OAAK,MAAM,CAAC,eAAe,gBAAgB,MAAM,gBAAgB,GAAG,CAClE,KACE,eAAe,IAAI,cAAc,IAChC,0BAA0B,+BAA+B,YAAY,CAEtE,cAAa,IAAI,eAAe,YAAY;MAE5C,oBAAmB,IAAI,cAAc;AAGzC,QAAM,gBAAgB,cAAc,GAAG;AAEvC,SAAO;GACP"}

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

@@ -1,184 +1,110 @@
 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 { assert as assert$1, readonlyArray, readonlyObject, readonlyRecord, valita_exports } from "../../../shared/src/valita.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()
+import { toRefs } from "../dag/chunk.js";
+import { indexDefinitionsEqual, indexDefinitionsSchema } from "../index-defs.js";
+//#region ../replicache/src/persist/client-groups.ts
+var clientGroupSchema = readonlyObject({
+	headHash: hashSchema,
+	mutatorNames: readonlyArray(valita_exports.string()),
+	indexes: indexDefinitionsSchema,
+	mutationIDs: readonlyRecord(valita_exports.number()),
+	lastServerAckdMutationIDs: valita_exports.record(valita_exports.number()),
+	disabled: valita_exports.boolean()
 });
-const CLIENT_GROUPS_HEAD_NAME = "client-groups";
+var CLIENT_GROUPS_HEAD_NAME = "client-groups";
 function assertClientGroup(value) {
-  assert$1(value, clientGroupSchema);
+	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;
+	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);
+	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);
+	return chunkDataToClientGroupMap((await dagRead.getChunk(hash))?.data);
 }
 async function getClientGroups(dagRead) {
-  const hash = await dagRead.getHead(CLIENT_GROUPS_HEAD_NAME);
-  if (!hash) {
-    return /* @__PURE__ */ new Map();
-  }
-  return getClientGroupsAtHash(hash, 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);
+	const currClientGroups = await getClientGroups(dagWrite);
+	for (const [clientGroupID, clientGroup] of clientGroups) validateClientGroupUpdate(clientGroup, currClientGroups.get(clientGroupID));
+	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);
+	const currClientGroups = await getClientGroups(dagWrite);
+	validateClientGroupUpdate(clientGroup, currClientGroups.get(clientGroupID));
+	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."
-    );
-  }
+	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;
+	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;
+	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);
+	return (await getClientGroups(dagRead)).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;
+	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;
 }
+/**
+* Marks a client group as disabled. This can happen if the server deletes the
+* client group (servers should not delete clients or client groups but it often
+* happens in practice when developing).
+*
+* A disabled client group prevents pulls and pushes from happening.
+*/
 async function disableClientGroup(clientGroupID, dagWrite) {
-  const clientGroup = await getClientGroup(clientGroupID, dagWrite);
-  if (!clientGroup) {
-    return;
-  }
-  const disabledClientGroup = {
-    ...clientGroup,
-    disabled: true
-  };
-  await setClientGroup(clientGroupID, disabledClientGroup, dagWrite);
+	const clientGroup = await getClientGroup(clientGroupID, dagWrite);
+	if (!clientGroup) return;
+	await setClientGroup(clientGroupID, {
+		...clientGroup,
+		disabled: true
+	}, dagWrite);
 }
-export {
-  CLIENT_GROUPS_HEAD_NAME,
-  clientGroupHasPendingMutations,
-  disableClientGroup,
-  getClientGroup,
-  getClientGroups,
-  mutatorNamesEqual,
-  setClientGroup,
-  setClientGroups
-};
-//# sourceMappingURL=client-groups.js.map
+//#endregion
+export { clientGroupHasPendingMutations, disableClientGroup, getClientGroup, getClientGroups, mutatorNamesEqual, setClientGroup, setClientGroups };
+
+//# sourceMappingURL=client-groups.js.map

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

@@ -1 +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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"}
+{"version":3,"file":"client-groups.js","names":[],"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"],"mappings":"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"}