atom.io 0.30.6 → 0.31.0

package/realtime-client/src/continuity/register-and-attempt-confirmed-update.ts

@@ -0,0 +1,231 @@
+import type * as AtomIO from "atom.io"
+import type { Func, Store } from "atom.io/internal"
+import {
+	actUponStore,
+	getEpochNumberOfContinuity,
+	ingestTransactionUpdate,
+	isRootStore,
+	setEpochNumberOfContinuity,
+	setIntoStore,
+} from "atom.io/internal"
+import {
+	confirmedUpdateQueue,
+	optimisticUpdateQueue,
+} from "atom.io/realtime-client"
+import type { Socket } from "atom.io/realtime-server"
+
+export const useRegisterAndAttemptConfirmedUpdate =
+	(
+		store: Store,
+		continuityKey: string,
+		socket: Socket,
+		optimisticUpdates: AtomIO.TransactionUpdate<any>[],
+		confirmedUpdates: AtomIO.TransactionUpdate<any>[],
+	) =>
+	(confirmed: AtomIO.TransactionUpdate<Func>): void => {
+		function reconcileEpoch(
+			optimisticUpdate: AtomIO.TransactionUpdate<any>,
+			confirmedUpdate: AtomIO.TransactionUpdate<any>,
+		): void {
+			store.logger.info(
+				`🧑‍⚖️`,
+				`continuity`,
+				continuityKey,
+				`reconciling updates`,
+			)
+			setIntoStore(store, optimisticUpdateQueue, (queue) => {
+				queue.shift()
+				return queue
+			})
+			if (optimisticUpdate.id === confirmedUpdate.id) {
+				const clientResult = JSON.stringify(optimisticUpdate.updates)
+				const serverResult = JSON.stringify(confirmedUpdate.updates)
+				if (clientResult === serverResult) {
+					store.logger.info(
+						`✅`,
+						`continuity`,
+						continuityKey,
+						`results for ${optimisticUpdate.id} match between client and server`,
+					)
+					socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch)
+					return
+				}
+			} else {
+				// id mismatch
+				store.logger.info(
+					`❌`,
+					`continuity`,
+					continuityKey,
+					`thought update #${confirmedUpdate.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate.key}:${confirmedUpdate.id}`,
+				)
+			}
+			store.logger.info(
+				`🧑‍⚖️`,
+				`continuity`,
+				continuityKey,
+				`updates do not match`,
+				optimisticUpdate,
+				confirmedUpdate,
+			)
+			const reversedOptimisticUpdates = optimisticUpdates.toReversed()
+			for (const subsequentOptimistic of reversedOptimisticUpdates) {
+				ingestTransactionUpdate(`oldValue`, subsequentOptimistic, store)
+			}
+			store.logger.info(
+				`⏪`,
+				`continuity`,
+				continuityKey,
+				`undid optimistic updates:`,
+				reversedOptimisticUpdates,
+			)
+			ingestTransactionUpdate(`oldValue`, optimisticUpdate, store)
+			store.logger.info(
+				`⏪`,
+				`continuity`,
+				continuityKey,
+				`undid zeroth optimistic update`,
+				optimisticUpdate,
+			)
+			ingestTransactionUpdate(`newValue`, confirmedUpdate, store)
+			store.logger.info(
+				`⏩`,
+				`continuity`,
+				continuityKey,
+				`applied confirmed update`,
+				confirmedUpdate,
+			)
+			socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch)
+
+			for (const subsequentOptimistic of optimisticUpdates) {
+				const token = {
+					type: `transaction`,
+					key: subsequentOptimistic.key,
+				} as const
+				const { id, params } = subsequentOptimistic
+				actUponStore(token, id, store)(...params)
+			}
+			store.logger.info(
+				`⏩`,
+				`continuity`,
+				continuityKey,
+				`reapplied subsequent optimistic updates:`,
+				optimisticUpdates,
+			)
+		}
+
+		store.logger.info(
+			`🧑‍⚖️`,
+			`continuity`,
+			continuityKey,
+			`integrating confirmed update`,
+			{ confirmedUpdate: confirmed, confirmedUpdates, optimisticUpdates },
+		)
+		const zerothOptimisticUpdate = optimisticUpdates[0]
+		if (zerothOptimisticUpdate) {
+			store.logger.info(
+				`🧑‍⚖️`,
+				`continuity`,
+				continuityKey,
+				`has optimistic updates to reconcile`,
+			)
+			if (confirmed.epoch === zerothOptimisticUpdate.epoch) {
+				store.logger.info(
+					`🧑‍⚖️`,
+					`continuity`,
+					continuityKey,
+					`epoch of confirmed update #${confirmed.epoch} matches zeroth optimistic update`,
+				)
+				reconcileEpoch(zerothOptimisticUpdate, confirmed)
+				for (const nextConfirmed of confirmedUpdates) {
+					const nextOptimistic = optimisticUpdates[0]
+					if (nextConfirmed.epoch === nextOptimistic?.epoch) {
+						reconcileEpoch(nextOptimistic, nextConfirmed)
+					} else {
+						break
+					}
+				}
+			} else {
+				// epoch mismatch
+				store.logger.info(
+					`🧑‍⚖️`,
+					`continuity`,
+					continuityKey,
+					`epoch of confirmed update #${confirmed.epoch} does not match zeroth optimistic update #${zerothOptimisticUpdate.epoch}`,
+				)
+				const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
+					(update) => update.epoch === confirmed.epoch,
+				)
+				if (!confirmedUpdateIsAlreadyEnqueued) {
+					store.logger.info(
+						`👈`,
+						`continuity`,
+						continuityKey,
+						`pushing confirmed update to queue`,
+						confirmed,
+					)
+					setIntoStore(store, confirmedUpdateQueue, (queue) => {
+						queue.push(confirmed)
+						queue.sort((a, b) => a.epoch - b.epoch)
+						return queue
+					})
+				}
+			}
+		} else {
+			store.logger.info(
+				`🧑‍⚖️`,
+				`continuity`,
+				continuityKey,
+				`has no optimistic updates to deal with`,
+			)
+			const continuityEpoch = getEpochNumberOfContinuity(continuityKey, store)
+			const isRoot = isRootStore(store)
+
+			if (isRoot && continuityEpoch === confirmed.epoch - 1) {
+				store.logger.info(
+					`✅`,
+					`continuity`,
+					continuityKey,
+					`integrating update #${confirmed.epoch} (${confirmed.key} ${confirmed.id})`,
+				)
+				ingestTransactionUpdate(`newValue`, confirmed, store)
+				socket.emit(`ack:${continuityKey}`, confirmed.epoch)
+				setEpochNumberOfContinuity(continuityKey, confirmed.epoch, store)
+			} else if (isRoot && continuityEpoch !== undefined) {
+				store.logger.info(
+					`🧑‍⚖️`,
+					`continuity`,
+					continuityKey,
+					`received update #${confirmed.epoch} but still waiting for update #${
+						continuityEpoch + 1
+					}`,
+					{
+						clientEpoch: continuityEpoch,
+						serverEpoch: confirmed.epoch,
+					},
+				)
+				const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
+					(update) => update.epoch === confirmed.epoch,
+				)
+				if (confirmedUpdateIsAlreadyEnqueued) {
+					store.logger.info(
+						`👍`,
+						`continuity`,
+						continuityKey,
+						`confirmed update #${confirmed.epoch} is already enqueued`,
+					)
+				} else {
+					store.logger.info(
+						`👈`,
+						`continuity`,
+						continuityKey,
+						`pushing confirmed update #${confirmed.epoch} to queue`,
+					)
+					setIntoStore(store, confirmedUpdateQueue, (queue) => {
+						queue.push(confirmed)
+						queue.sort((a, b) => a.epoch - b.epoch)
+						return queue
+					})
+				}
+			}
+		}
+	}

package/realtime-client/src/continuity/use-conceal-state.ts

@@ -0,0 +1,11 @@
+import type { AtomToken } from "atom.io"
+import type { Store } from "atom.io/internal"
+import { disposeAtom } from "atom.io/internal"
+
+export function useConcealState(store: Store) {
+	return (concealed: AtomToken<unknown>[]): void => {
+		for (const token of concealed) {
+			disposeAtom(token, store)
+		}
+	}
+}

package/realtime-client/src/continuity/use-reveal-state.ts

@@ -0,0 +1,19 @@
+import { setIntoStore, type Store } from "atom.io/internal"
+import type { Json } from "atom.io/json"
+
+export function useRevealState(store: Store) {
+	return (revealed: Json.Array): void => {
+		let i = 0
+		let k: any
+		let v: any
+		for (const x of revealed) {
+			if (i % 2 === 0) {
+				k = x
+			} else {
+				v = x
+				setIntoStore(store, k, v)
+			}
+			i++
+		}
+	}
+}

package/realtime-client/src/index.ts

@@ -1,3 +1,4 @@
+export * from "./continuity"
 export * from "./pull-atom"
 export * from "./pull-atom-family-member"
 export * from "./pull-mutable-atom"

package/realtime-client/src/sync-continuity.ts

@@ -1,21 +1,13 @@
-import type * as AtomIO from "atom.io"
-import type { Func, Store } from "atom.io/internal"
+import type { Store } from "atom.io/internal"
 import {
-	actUponStore,
 	assignTransactionToContinuity,
-	disposeAtom,
-	getEpochNumberOfContinuity,
 	getFromStore,
 	getJsonToken,
-	growMoleculeInStore,
-	ingestTransactionUpdate,
-	initFamilyMemberInStore,
-	isRootStore,
 	setEpochNumberOfContinuity,
 	setIntoStore,
 	subscribeToTransaction,
 } from "atom.io/internal"
-import { type Json, parseJson } from "atom.io/json"
+import type { Json } from "atom.io/json"
 import type { ContinuityToken } from "atom.io/realtime"
 import {
 	confirmedUpdateQueue,
@@ -23,7 +15,11 @@ import {
 } from "atom.io/realtime-client"
 import type { Socket } from "socket.io-client"
 
-export function syncContinuity<F extends Func>(
+import { useRegisterAndAttemptConfirmedUpdate } from "./continuity/register-and-attempt-confirmed-update"
+import { useConcealState } from "./continuity/use-conceal-state"
+import { useRevealState } from "./continuity/use-reveal-state"
+
+export function syncContinuity(
 	continuity: ContinuityToken,
 	socket: Socket,
 	store: Store,
@@ -54,215 +50,13 @@ export function syncContinuity<F extends Func>(
 	socket.off(`continuity-init:${continuityKey}`)
 	socket.on(`continuity-init:${continuityKey}`, initializeContinuity)
 
-	const registerAndAttemptConfirmedUpdate = (
-		confirmed: AtomIO.TransactionUpdate<F>,
-	) => {
-		function reconcileEpoch(
-			optimisticUpdate: AtomIO.TransactionUpdate<any>,
-			confirmedUpdate: AtomIO.TransactionUpdate<any>,
-		): void {
-			store.logger.info(
-				`🧑‍⚖️`,
-				`continuity`,
-				continuityKey,
-				`reconciling updates`,
-			)
-			setIntoStore(store, optimisticUpdateQueue, (queue) => {
-				queue.shift()
-				return queue
-			})
-			if (optimisticUpdate.id === confirmedUpdate.id) {
-				const clientResult = JSON.stringify(optimisticUpdate.updates)
-				const serverResult = JSON.stringify(confirmedUpdate.updates)
-				if (clientResult === serverResult) {
-					store.logger.info(
-						`✅`,
-						`continuity`,
-						continuityKey,
-						`results for ${optimisticUpdate.id} match between client and server`,
-					)
-					socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch)
-					return
-				}
-			} else {
-				// id mismatch
-				store.logger.info(
-					`❌`,
-					`continuity`,
-					continuityKey,
-					`thought update #${confirmedUpdate.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate.key}:${confirmedUpdate.id}`,
-				)
-			}
-			store.logger.info(
-				`🧑‍⚖️`,
-				`continuity`,
-				continuityKey,
-				`updates do not match`,
-				optimisticUpdate,
-				confirmedUpdate,
-			)
-			const reversedOptimisticUpdates = optimisticUpdates.toReversed()
-			for (const subsequentOptimistic of reversedOptimisticUpdates) {
-				ingestTransactionUpdate(`oldValue`, subsequentOptimistic, store)
-			}
-			store.logger.info(
-				`⏪`,
-				`continuity`,
-				continuityKey,
-				`undid optimistic updates:`,
-				reversedOptimisticUpdates,
-			)
-			ingestTransactionUpdate(`oldValue`, optimisticUpdate, store)
-			store.logger.info(
-				`⏪`,
-				`continuity`,
-				continuityKey,
-				`undid zeroth optimistic update`,
-				optimisticUpdate,
-			)
-			ingestTransactionUpdate(`newValue`, confirmedUpdate, store)
-			store.logger.info(
-				`⏩`,
-				`continuity`,
-				continuityKey,
-				`applied confirmed update`,
-				confirmedUpdate,
-			)
-			socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch)
-
-			for (const subsequentOptimistic of optimisticUpdates) {
-				const token = {
-					type: `transaction`,
-					key: subsequentOptimistic.key,
-				} as const
-				const { id, params } = subsequentOptimistic
-				actUponStore(token, id, store)(...params)
-			}
-			store.logger.info(
-				`⏩`,
-				`continuity`,
-				continuityKey,
-				`reapplied subsequent optimistic updates:`,
-				optimisticUpdates,
-			)
-		}
-
-		store.logger.info(
-			`🧑‍⚖️`,
-			`continuity`,
-			continuityKey,
-			`integrating confirmed update`,
-			{ confirmedUpdate: confirmed, confirmedUpdates, optimisticUpdates },
-		)
-		const zerothOptimisticUpdate = optimisticUpdates[0]
-		if (zerothOptimisticUpdate) {
-			store.logger.info(
-				`🧑‍⚖️`,
-				`continuity`,
-				continuityKey,
-				`has optimistic updates to reconcile`,
-			)
-			if (confirmed.epoch === zerothOptimisticUpdate.epoch) {
-				store.logger.info(
-					`🧑‍⚖️`,
-					`continuity`,
-					continuityKey,
-					`epoch of confirmed update #${confirmed.epoch} matches zeroth optimistic update`,
-				)
-				reconcileEpoch(zerothOptimisticUpdate, confirmed)
-				for (const nextConfirmed of confirmedUpdates) {
-					const nextOptimistic = optimisticUpdates[0]
-					if (nextConfirmed.epoch === nextOptimistic?.epoch) {
-						reconcileEpoch(nextOptimistic, nextConfirmed)
-					} else {
-						break
-					}
-				}
-			} else {
-				// epoch mismatch
-				store.logger.info(
-					`🧑‍⚖️`,
-					`continuity`,
-					continuityKey,
-					`epoch of confirmed update #${confirmed.epoch} does not match zeroth optimistic update #${zerothOptimisticUpdate.epoch}`,
-				)
-				const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
-					(update) => update.epoch === confirmed.epoch,
-				)
-				if (!confirmedUpdateIsAlreadyEnqueued) {
-					store.logger.info(
-						`👈`,
-						`continuity`,
-						continuityKey,
-						`pushing confirmed update to queue`,
-						confirmed,
-					)
-					setIntoStore(store, confirmedUpdateQueue, (queue) => {
-						queue.push(confirmed)
-						queue.sort((a, b) => a.epoch - b.epoch)
-						return queue
-					})
-				}
-			}
-		} else {
-			store.logger.info(
-				`🧑‍⚖️`,
-				`continuity`,
-				continuityKey,
-				`has no optimistic updates to deal with`,
-			)
-			const continuityEpoch = getEpochNumberOfContinuity(continuityKey, store)
-			const isRoot = isRootStore(store)
-
-			if (isRoot && continuityEpoch === confirmed.epoch - 1) {
-				store.logger.info(
-					`✅`,
-					`continuity`,
-					continuityKey,
-					`integrating update #${confirmed.epoch} (${confirmed.key} ${confirmed.id})`,
-				)
-				ingestTransactionUpdate(`newValue`, confirmed, store)
-				socket.emit(`ack:${continuityKey}`, confirmed.epoch)
-				setEpochNumberOfContinuity(continuityKey, confirmed.epoch, store)
-			} else if (isRoot && continuityEpoch !== undefined) {
-				store.logger.info(
-					`🧑‍⚖️`,
-					`continuity`,
-					continuityKey,
-					`received update #${confirmed.epoch} but still waiting for update #${
-						continuityEpoch + 1
-					}`,
-					{
-						clientEpoch: continuityEpoch,
-						serverEpoch: confirmed.epoch,
-					},
-				)
-				const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
-					(update) => update.epoch === confirmed.epoch,
-				)
-				if (confirmedUpdateIsAlreadyEnqueued) {
-					store.logger.info(
-						`👍`,
-						`continuity`,
-						continuityKey,
-						`confirmed update #${confirmed.epoch} is already enqueued`,
-					)
-				} else {
-					store.logger.info(
-						`👈`,
-						`continuity`,
-						continuityKey,
-						`pushing confirmed update #${confirmed.epoch} to queue`,
-					)
-					setIntoStore(store, confirmedUpdateQueue, (queue) => {
-						queue.push(confirmed)
-						queue.sort((a, b) => a.epoch - b.epoch)
-						return queue
-					})
-				}
-			}
-		}
-	}
+	const registerAndAttemptConfirmedUpdate = useRegisterAndAttemptConfirmedUpdate(
+		store,
+		continuityKey,
+		socket,
+		optimisticUpdates,
+		confirmedUpdates,
+	)
 	socket.off(`tx-new:${continuityKey}`)
 	socket.on(`tx-new:${continuityKey}`, registerAndAttemptConfirmedUpdate)
 
@@ -316,28 +110,10 @@ export function syncContinuity<F extends Func>(
 		return unsubscribeFromTransactionUpdates
 	})
 
-	socket.on(`reveal:${continuityKey}`, (revealed: Json.Array) => {
-		let i = 0
-		let k: any
-		let v: any
-		for (const x of revealed) {
-			if (i % 2 === 0) {
-				k = x
-			} else {
-				v = x
-				upsertState(k, v, store)
-			}
-			i++
-		}
-	})
-	socket.on(
-		`conceal:${continuityKey}`,
-		(concealed: AtomIO.AtomToken<unknown>[]) => {
-			for (const token of concealed) {
-				disposeAtom(token, store)
-			}
-		},
-	)
+	const revealState = useRevealState(store)
+	const concealState = useConcealState(store)
+	socket.on(`reveal:${continuityKey}`, revealState)
+	socket.on(`conceal:${continuityKey}`, concealState)
 
 	socket.emit(`get:${continuityKey}`)
 	return () => {
@@ -347,23 +123,3 @@ export function syncContinuity<F extends Func>(
 		// socket.emit(`unsub:${continuityKey}`)
 	}
 }
-
-function upsertState<T>(
-	store: Store,
-	token: AtomIO.WritableToken<T>,
-	value: T,
-): void {
-	if (token.family) {
-		const family = store.families.get(token.family.key)
-		if (family) {
-			const molecule = store.molecules.get(token.family.subKey)
-			if (molecule) {
-				growMoleculeInStore(molecule, family, store)
-			} else if (store.config.lifespan === `immortal`) {
-				throw new Error(`No molecule found for key "${token.family.subKey}"`)
-			}
-			initFamilyMemberInStore(store, family, parseJson(token.family.subKey))
-		}
-	}
-	setIntoStore(store, token, value)
-}

package/realtime-react/dist/index.js

@@ -19,7 +19,7 @@ var RealtimeProvider = ({ children, socket }) => {
       setMyId(socket.id);
     });
     socket?.on(`disconnect`, () => {
-      setMyId(void 0);
+      setMyId(undefined);
     });
   }, [socket, setMyId]);
   return /* @__PURE__ */ jsx(RealtimeContext.Provider, { value: { socket, services }, children });
@@ -61,7 +61,7 @@ function useRealtimeService(key, create) {
     if (service) {
       service[0]++;
     } else {
-      const dispose = socket ? create(socket) : void 0;
+      const dispose = socket ? create(socket) : undefined;
       service = [1, dispose];
       services?.set(key, service);
     }

package/realtime-server/dist/index.d.ts

@@ -126,7 +126,7 @@ type StateReceiver = ReturnType<typeof realtimeStateReceiver>;
 declare function realtimeStateReceiver({ socket, store, }: ServerConfig): <J extends Json.Serializable>(token: WritableToken<J>) => () => void;
 
 type Socket = {
-    id: string;
+    id: string | undefined;
     on: (event: string, listener: (...args: Json.Serializable[]) => void) => void;
     onAny: (listener: (event: string, ...args: Json.Serializable[]) => void) => void;
     off: (event: string, listener: (...args: Json.Serializable[]) => void) => void;

package/realtime-server/dist/index.js

@@ -960,7 +960,7 @@ function realtimeStateProvider({
         socket.off(`unsub:${token.key}`, fillUnsubRequest);
         if (unsubscribeFromStateUpdates) {
           unsubscribeFromStateUpdates();
-          unsubscribeFromStateUpdates = void 0;
+          unsubscribeFromStateUpdates = undefined;
         }
       };
       socket.on(`unsub:${token.key}`, fillUnsubRequest);
@@ -970,7 +970,7 @@ function realtimeStateProvider({
       socket.off(`sub:${token.key}`, fillSubRequest);
       if (unsubscribeFromStateUpdates) {
         unsubscribeFromStateUpdates();
-        unsubscribeFromStateUpdates = void 0;
+        unsubscribeFromStateUpdates = undefined;
       }
     };
   };

package/realtime-server/src/index.ts

@@ -12,7 +12,7 @@ export * from "./realtime-state-provider"
 export * from "./realtime-state-receiver"
 
 export type Socket = {
-	id: string
+	id: string | undefined
 	on: (event: string, listener: (...args: Json.Serializable[]) => void) => void
 	onAny: (
 		listener: (event: string, ...args: Json.Serializable[]) => void,

package/realtime-testing/dist/index.js

@@ -2,7 +2,6 @@ import '../../dist/chunk-XWL6SNVU.js';
 import * as http from 'node:http';
 import { render, prettyDOM } from '@testing-library/react';
 import * as AtomIO from 'atom.io';
-import { realm } from 'atom.io';
 import { editRelationsInStore, findRelationsInStore } from 'atom.io/data';
 import { IMPLICIT, findInStore, setIntoStore, getFromStore, clearStore } from 'atom.io/internal';
 import { toEntries } from 'atom.io/json';
@@ -18,7 +17,7 @@ import { jsx } from 'react/jsx-runtime';
 
 var testNumber = 0;
 function prefixLogger(store, prefix) {
-  store.loggers[0] = new AtomIO.AtomIOLogger(`info`, void 0, {
+  store.loggers[0] = new AtomIO.AtomIOLogger(`info`, undefined, {
     info: (...args) => {
       console.info(prefix, ...args);
     },
@@ -39,7 +38,7 @@ var setupRealtimeTestServer = (options) => {
     },
     IMPLICIT.STORE
   );
-  const socketRealm = realm(silo.store);
+  const socketRealm = new AtomIO.Realm(silo.store);
   const httpServer = http.createServer((_, res) => res.end(`Hello World!`));
   const address = httpServer.listen(options.port).address();
   const port = typeof address === `string` ? null : address === null ? null : address.port;

package/realtime-testing/src/setup-realtime-test.tsx

@@ -3,7 +3,6 @@ import * as http from "node:http"
 import type { RenderResult } from "@testing-library/react"
 import { prettyDOM, render } from "@testing-library/react"
 import * as AtomIO from "atom.io"
-import { realm } from "atom.io"
 import { editRelationsInStore, findRelationsInStore } from "atom.io/data"
 import type { Store } from "atom.io/internal"
 import {
@@ -105,7 +104,7 @@ export const setupRealtimeTestServer = (
 		},
 		IMPLICIT.STORE,
 	)
-	const socketRealm = realm<RTS.SocketSystemHierarchy>(silo.store)
+	const socketRealm = new AtomIO.Realm<RTS.SocketSystemHierarchy>(silo.store)
 
 	const httpServer = http.createServer((_, res) => res.end(`Hello World!`))
 	const address = httpServer.listen(options.port).address()