atom.io 0.17.0 → 0.18.1

package/realtime-client/src/{pull-mutable-family-member.ts → pull-mutable-atom-family-member.ts}

@@ -5,7 +5,7 @@ import { parseJson } from "atom.io/json"
 import type { Json } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
-export function pullMutableFamilyMember<
+export function pullMutableAtomFamilyMember<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
 >(
@@ -19,20 +19,20 @@ export function pullMutableFamilyMember<
 	}
 	const { key: familyKey, subKey: serializedSubKey } = token.family
 	const subKey = parseJson(serializedSubKey)
-	socket?.on(`init:${token.key}`, (data: J) => {
+	socket.on(`init:${token.key}`, (data: J) => {
 		const jsonToken = getJsonToken(token)
 		setIntoStore(jsonToken, data, store)
 	})
-	socket?.on(
+	socket.on(
 		`next:${token.key}`,
 		(data: T extends Transceiver<infer Signal> ? Signal : never) => {
 			const trackerToken = getUpdateToken(token)
 			setIntoStore(trackerToken, data, store)
 		},
 	)
-	socket?.emit(`sub:${familyKey}`, subKey)
+	socket.emit(`sub:${familyKey}`, subKey)
 	return () => {
-		socket?.off(`serve:${token.key}`)
-		socket?.emit(`unsub:${token.key}`)
+		socket.off(`serve:${token.key}`)
+		socket.emit(`unsub:${token.key}`)
 	}
 }

package/realtime-client/src/{pull-mutable.ts → pull-mutable-atom.ts}

@@ -4,7 +4,7 @@ import { getJsonToken, getUpdateToken, setIntoStore } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
-export function pullMutableState<
+export function pullMutableAtom<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
 >(

package/realtime-client/src/pull-selector-family-member.ts

@@ -0,0 +1,42 @@
+import type * as AtomIO from "atom.io"
+import type { Store } from "atom.io/internal"
+import type { Socket } from "socket.io-client"
+
+import { pullAtomFamilyMember } from "./pull-atom-family-member"
+import { pullMutableAtomFamilyMember } from "./pull-mutable-atom-family-member"
+
+export function pullSelectorFamilyMember<T>(
+	token: AtomIO.SelectorToken<T>,
+	socket: Socket,
+	store: Store,
+): () => void {
+	if (!(`family` in token)) {
+		console.error(`Token is not a family member:`, token)
+		return () => {}
+	}
+	const atomKeys = store.selectorAtoms.getRelatedKeys(token.key)
+	const unsubscribes: Array<() => void> = []
+	if (atomKeys) {
+		for (const atomKey of atomKeys) {
+			const atom = store.atoms.get(atomKey)
+			if (!atom) {
+				continue
+			}
+			switch (atom.type) {
+				case `atom`: {
+					unsubscribes.push(pullAtomFamilyMember(atom, socket, store))
+					break
+				}
+				case `mutable_atom`: {
+					unsubscribes.push(pullMutableAtomFamilyMember(atom, socket, store))
+					break
+				}
+			}
+		}
+	}
+	return () => {
+		for (const unsubscribe of unsubscribes) {
+			unsubscribe()
+		}
+	}
+}

package/realtime-client/src/pull-selector.ts

@@ -0,0 +1,38 @@
+import type * as AtomIO from "atom.io"
+import type { Store } from "atom.io/internal"
+import type { Socket } from "socket.io-client"
+
+import { pullAtom } from "./pull-atom"
+import { pullMutableAtom } from "./pull-mutable-atom"
+
+export function pullSelector<T>(
+	token: AtomIO.SelectorToken<T>,
+	socket: Socket,
+	store: Store,
+): () => void {
+	const atomKeys = store.selectorAtoms.getRelatedKeys(token.key)
+	const unsubscribes: Array<() => void> = []
+	if (atomKeys) {
+		for (const atomKey of atomKeys) {
+			const atom = store.atoms.get(atomKey)
+			if (!atom) {
+				continue
+			}
+			switch (atom.type) {
+				case `atom`: {
+					unsubscribes.push(pullAtom(atom, socket, store))
+					break
+				}
+				case `mutable_atom`: {
+					unsubscribes.push(pullMutableAtom(atom, socket, store))
+					break
+				}
+			}
+		}
+	}
+	return () => {
+		for (const unsubscribe of unsubscribes) {
+			unsubscribe()
+		}
+	}
+}

package/realtime-client/src/realtime-client-stores/client-main-store.ts

@@ -1,10 +1,20 @@
 import * as AtomIO from "atom.io"
 
+import { lazyLocalStorageEffect } from "~/packages/atom.io/__unstable__/web-effects/src/storage"
+
 export const myIdState__INTERNAL = AtomIO.atom<string | undefined>({
-	key: `myId__INTERNAL`,
+	key: `mySocketId__INTERNAL`,
 	default: undefined,
 })
 export const myIdState = AtomIO.selector<string | undefined>({
-	key: `myId`,
+	key: `mySocketId`,
 	get: ({ get }) => get(myIdState__INTERNAL),
 })
+
+const usernameEffects =
+	typeof window === `undefined` ? [] : [lazyLocalStorageEffect(`myUsername`)]
+export const myUsernameState = AtomIO.atom<string | null>({
+	key: `myUsername`,
+	default: null,
+	effects: usernameEffects,
+})

package/realtime-client/src/realtime-client-stores/client-sync-store.ts

@@ -1,15 +1,15 @@
 import * as AtomIO from "atom.io"
 
-export const optimisticUpdateQueueState = AtomIO.atom<
+export const optimisticUpdateQueue = AtomIO.atom<
 	AtomIO.TransactionUpdate<any>[]
 >({
 	key: `updateQueue`,
 	default: [],
 })
 
-export const confirmedUpdateQueueState = AtomIO.atom<
-	AtomIO.TransactionUpdate<any>[]
->({
-	key: `serverConfirmedUpdateQueue`,
-	default: [],
-})
+export const confirmedUpdateQueue = AtomIO.atom<AtomIO.TransactionUpdate<any>[]>(
+	{
+		key: `serverConfirmedUpdateQueue`,
+		default: [],
+	},
+)

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

@@ -0,0 +1,368 @@
+import type * as AtomIO from "atom.io"
+import type { Store } from "atom.io/internal"
+import { deleteAtom } from "atom.io/internal"
+import {
+	actUponStore,
+	assignTransactionToContinuity,
+	getEpochNumberOfContinuity,
+	getFromStore,
+	getJsonToken,
+	ingestTransactionUpdate,
+	isRootStore,
+	setEpochNumberOfContinuity,
+	setIntoStore,
+	subscribeToTransaction,
+} from "atom.io/internal"
+import type { Json } from "atom.io/json"
+import type { ContinuityToken } from "atom.io/realtime"
+import {
+	confirmedUpdateQueue,
+	optimisticUpdateQueue,
+} from "atom.io/realtime-client"
+import type { Socket } from "socket.io-client"
+
+export function syncContinuity<ƒ extends AtomIO.ƒn>(
+	continuity: ContinuityToken,
+	socket: Socket,
+	store: Store,
+): () => void {
+	const continuityKey = continuity.key
+	const optimisticUpdates = getFromStore(optimisticUpdateQueue, store)
+	const confirmedUpdates = getFromStore(confirmedUpdateQueue, store)
+
+	const initializeContinuity = (epoch: number, payload: Json.Array) => {
+		socket.off(`continuity-init:${continuityKey}`, initializeContinuity)
+		let i = 0
+		let k: any = ``
+		let v: any = null
+		for (const x of payload) {
+			if (i % 2 === 0) {
+				k = x
+			} else {
+				v = x
+				// console.log(`❗❗❗❗❗`, k, v)
+				if (`type` in k && k.type === `mutable_atom`) {
+					k = getJsonToken(k)
+				}
+				setIntoStore(k, v, store)
+			}
+			i++
+		}
+		setEpochNumberOfContinuity(continuityKey, epoch, store)
+	}
+	socket.off(`continuity-init:${continuityKey}`)
+	socket.on(`continuity-init:${continuityKey}`, initializeContinuity)
+
+	const registerAndAttemptConfirmedUpdate = (
+		confirmedUpdate: AtomIO.TransactionUpdate<ƒ>,
+	) => {
+		function reconcileEpoch(
+			optimisticUpdate: AtomIO.TransactionUpdate<any>,
+			confirmedUpdate: AtomIO.TransactionUpdate<any>,
+		): void {
+			store.logger.info(
+				`🧑‍⚖️`,
+				`continuity`,
+				continuityKey,
+				`reconciling updates`,
+			)
+			setIntoStore(
+				optimisticUpdateQueue,
+				(queue) => {
+					queue.shift()
+					return queue
+				},
+				store,
+			)
+			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, confirmedUpdates, optimisticUpdates },
+		)
+		const zerothOptimisticUpdate = optimisticUpdates[0]
+		if (zerothOptimisticUpdate) {
+			store.logger.info(
+				`🧑‍⚖️`,
+				`continuity`,
+				continuityKey,
+				`has optimistic updates to reconcile`,
+			)
+			if (confirmedUpdate.epoch === zerothOptimisticUpdate.epoch) {
+				store.logger.info(
+					`🧑‍⚖️`,
+					`continuity`,
+					continuityKey,
+					`epoch of confirmed update #${confirmedUpdate.epoch} matches zeroth optimistic update`,
+				)
+				reconcileEpoch(zerothOptimisticUpdate, confirmedUpdate)
+				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 #${confirmedUpdate.epoch} does not match zeroth optimistic update #${zerothOptimisticUpdate.epoch}`,
+				)
+				const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
+					(update) => update.epoch === confirmedUpdate.epoch,
+				)
+				if (!confirmedUpdateIsAlreadyEnqueued) {
+					store.logger.info(
+						`👈`,
+						`continuity`,
+						continuityKey,
+						`pushing confirmed update to queue`,
+						confirmedUpdate,
+					)
+					setIntoStore(
+						confirmedUpdateQueue,
+						(queue) => {
+							queue.push(confirmedUpdate)
+							queue.sort((a, b) => a.epoch - b.epoch)
+							return queue
+						},
+						store,
+					)
+				}
+			}
+		} 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 === confirmedUpdate.epoch - 1) {
+				store.logger.info(
+					`✅`,
+					`continuity`,
+					continuityKey,
+					`integrating update #${confirmedUpdate.epoch} (${confirmedUpdate.key} ${confirmedUpdate.id})`,
+				)
+				ingestTransactionUpdate(`newValue`, confirmedUpdate, store)
+				socket.emit(`ack:${continuityKey}`, confirmedUpdate.epoch)
+				setEpochNumberOfContinuity(continuityKey, confirmedUpdate.epoch, store)
+			} else if (isRoot && continuityEpoch !== undefined) {
+				store.logger.info(
+					`🧑‍⚖️`,
+					`continuity`,
+					continuityKey,
+					`received update #${
+						confirmedUpdate.epoch
+					} but still waiting for update #${continuityEpoch + 1}`,
+					{
+						clientEpoch: continuityEpoch,
+						serverEpoch: confirmedUpdate.epoch,
+					},
+				)
+				const confirmedUpdateIsAlreadyEnqueued = confirmedUpdates.some(
+					(update) => update.epoch === confirmedUpdate.epoch,
+				)
+				if (confirmedUpdateIsAlreadyEnqueued) {
+					store.logger.info(
+						`👍`,
+						`continuity`,
+						continuityKey,
+						`confirmed update #${confirmedUpdate.epoch} is already enqueued`,
+					)
+				} else {
+					store.logger.info(
+						`👈`,
+						`continuity`,
+						continuityKey,
+						`pushing confirmed update #${confirmedUpdate.epoch} to queue`,
+					)
+					setIntoStore(
+						confirmedUpdateQueue,
+						(queue) => {
+							queue.push(confirmedUpdate)
+							queue.sort((a, b) => a.epoch - b.epoch)
+							return queue
+						},
+						store,
+					)
+				}
+			}
+		}
+	}
+	socket.off(`tx-new:${continuityKey}`)
+	socket.on(`tx-new:${continuityKey}`, registerAndAttemptConfirmedUpdate)
+
+	const unsubscribeFunctions = continuity.actions.map((transaction) => {
+		assignTransactionToContinuity(continuityKey, transaction.key, store)
+		const unsubscribeFromTransactionUpdates = subscribeToTransaction(
+			transaction,
+			(clientUpdate) => {
+				store.logger.info(
+					`🤞`,
+					`continuity`,
+					continuityKey,
+					`enqueuing optimistic update`,
+				)
+				const optimisticUpdateIndex = optimisticUpdates.findIndex(
+					(update) => update.id === clientUpdate.id,
+				)
+				if (optimisticUpdateIndex === -1) {
+					store.logger.info(
+						`🤞`,
+						`continuity`,
+						continuityKey,
+						`enqueuing new optimistic update`,
+					)
+					setIntoStore(
+						optimisticUpdateQueue,
+						(queue) => {
+							queue.push(clientUpdate)
+							queue.sort((a, b) => a.epoch - b.epoch)
+							return queue
+						},
+						store,
+					)
+				} else {
+					store.logger.info(
+						`🤞`,
+						`continuity`,
+						continuityKey,
+						`replacing existing optimistic update at index ${optimisticUpdateIndex}`,
+					)
+					setIntoStore(
+						optimisticUpdateQueue,
+						(queue) => {
+							queue[optimisticUpdateIndex] = clientUpdate
+							return queue
+						},
+						store,
+					)
+				}
+				socket.emit(`tx-run:${continuityKey}`, {
+					id: clientUpdate.id,
+					key: transaction.key,
+					params: clientUpdate.params,
+				})
+			},
+			`tx-run:${continuityKey}`,
+			store,
+		)
+		return unsubscribeFromTransactionUpdates
+	})
+
+	socket.on(`reveal:${continuityKey}`, (revealed: Json.Array) => {
+		let i = 0
+		let k: any = ``
+		let v: any = null
+		for (const x of revealed) {
+			if (i % 2 === 0) {
+				k = x
+			} else {
+				v = x
+				setIntoStore(k, v, store)
+			}
+			i++
+		}
+	})
+	socket.on(
+		`conceal:${continuityKey}`,
+		(concealed: AtomIO.AtomToken<unknown>[]) => {
+			for (const token of concealed) {
+				deleteAtom(token, store)
+			}
+		},
+	)
+
+	socket.emit(`get:${continuityKey}`)
+	return () => {
+		socket.off(`continuity-init:${continuityKey}`)
+		socket.off(`tx-new:${continuityKey}`)
+		for (const unsubscribe of unsubscribeFunctions) unsubscribe()
+		// socket.emit(`unsub:${continuityKey}`)
+	}
+}