atom.io 0.16.3 → 0.18.0

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

@@ -1,15 +1,15 @@
-import * as AtomIO from "atom.io"
-import type { Store } from "atom.io/internal"
+import type * as AtomIO from "atom.io"
+import { type Store, setIntoStore } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
-export function pullState<J extends Json.Serializable>(
-	token: AtomIO.WritableToken<J>,
+export function pullAtom<J extends Json.Serializable>(
+	token: AtomIO.RegularAtomToken<J>,
 	socket: Socket,
 	store: Store,
 ): () => void {
 	const setServedValue = (data: J) => {
-		AtomIO.setState(token, data, store)
+		setIntoStore(token, data, store)
 	}
 	socket.on(`serve:${token.key}`, setServedValue)
 	socket.emit(`sub:${token.key}`)

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

@@ -1,11 +1,11 @@
-import * as AtomIO from "atom.io"
-import { getJsonToken, getUpdateToken } from "atom.io/internal"
+import type * as AtomIO from "atom.io"
+import { getJsonToken, getUpdateToken, setIntoStore } from "atom.io/internal"
 import type { Store, Transceiver } from "atom.io/internal"
 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,
 >(
@@ -21,13 +21,13 @@ export function pullMutableFamilyMember<
 	const subKey = parseJson(serializedSubKey)
 	socket?.on(`init:${token.key}`, (data: J) => {
 		const jsonToken = getJsonToken(token)
-		AtomIO.setState(jsonToken, data, store)
+		setIntoStore(jsonToken, data, store)
 	})
 	socket?.on(
 		`next:${token.key}`,
 		(data: T extends Transceiver<infer Signal> ? Signal : never) => {
 			const trackerToken = getUpdateToken(token)
-			AtomIO.setState(trackerToken, data, store)
+			setIntoStore(trackerToken, data, store)
 		},
 	)
 	socket?.emit(`sub:${familyKey}`, subKey)

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

@@ -1,10 +1,10 @@
-import * as AtomIO from "atom.io"
+import type * as AtomIO from "atom.io"
 import type { Store, Transceiver } from "atom.io/internal"
-import { getJsonToken, getUpdateToken } from "atom.io/internal"
+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,
 >(
@@ -15,12 +15,12 @@ export function pullMutableState<
 	const jsonToken = getJsonToken(token)
 	const updateToken = getUpdateToken(token)
 	socket.on(`init:${token.key}`, (data: J) => {
-		AtomIO.setState(jsonToken, data, store)
+		setIntoStore(jsonToken, data, store)
 	})
 	socket.on(
 		`next:${token.key}`,
 		(data: T extends Transceiver<infer Update> ? Update : never) => {
-			AtomIO.setState(updateToken, data, store)
+			setIntoStore(updateToken, data, store)
 		},
 	)
 	socket.emit(`sub:${token.key}`)

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,10 @@
 import * as AtomIO from "atom.io"
 
 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),
 })

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,321 @@
+import type * as AtomIO from "atom.io"
+import type { Store } from "atom.io/internal"
+import {
+	actUponStore,
+	assignTransactionToContinuity,
+	getEpochNumberOfContinuity,
+	getFromStore,
+	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) => {
+		let i = 0
+		let k: any = ``
+		let v: any = null
+		for (const x of payload) {
+			if (i % 2 === 0) {
+				k = x
+			} else {
+				v = x
+				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}`,
+				)
+			}
+			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}`, clientUpdate)
+			},
+			`tx-run:${continuityKey}`,
+			store,
+		)
+		return unsubscribeFromTransactionUpdates
+	})
+
+	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}`)
+	}
+}

package/realtime-client/src/sync-server-action.ts

@@ -1,11 +1,10 @@
-import * as AtomIO from "atom.io"
+import type * as AtomIO from "atom.io"
 import * as Internal from "atom.io/internal"
 import type { Socket } from "socket.io-client"
 
-import { isRootStore } from "../../internal/src/transaction/is-root-store"
 import {
-	confirmedUpdateQueueState,
-	optimisticUpdateQueueState,
+	confirmedUpdateQueue,
+	optimisticUpdateQueue,
 } from "./realtime-client-stores"
 
 export function syncAction<ƒ extends AtomIO.ƒn>(
@@ -13,8 +12,10 @@ export function syncAction<ƒ extends AtomIO.ƒn>(
 	socket: Socket,
 	store: Internal.Store,
 ): () => void {
-	const optimisticQueue = AtomIO.getState(optimisticUpdateQueueState, store)
-	const confirmedQueue = AtomIO.getState(confirmedUpdateQueueState, store)
+	Internal.assignTransactionToContinuity(`default`, token.key, store)
+
+	const optimisticQueue = Internal.getFromStore(optimisticUpdateQueue, store)
+	const confirmedQueue = Internal.getFromStore(confirmedUpdateQueue, store)
 
 	const unsubscribeFromLocalUpdates = Internal.subscribeToTransaction(
 		token,
@@ -23,8 +24,8 @@ export function syncAction<ƒ extends AtomIO.ƒn>(
 				(update) => update.id === clientUpdate.id,
 			)
 			if (optimisticUpdateQueueIndex === -1) {
-				AtomIO.setState(
-					optimisticUpdateQueueState,
+				Internal.setIntoStore(
+					optimisticUpdateQueue,
 					(queue) => {
 						queue.push(clientUpdate)
 						queue.sort((a, b) => a.epoch - b.epoch)
@@ -32,18 +33,17 @@ export function syncAction<ƒ extends AtomIO.ƒn>(
 					},
 					store,
 				)
-				socket.emit(`tx-run:${token.key}`, clientUpdate)
 			} else {
-				AtomIO.setState(
-					optimisticUpdateQueueState,
+				Internal.setIntoStore(
+					optimisticUpdateQueue,
 					(queue) => {
 						queue[optimisticUpdateQueueIndex] = clientUpdate
 						return queue
 					},
 					store,
 				)
-				socket.emit(`tx-run:${token.key}`, clientUpdate)
 			}
+			socket.emit(`tx-run:${token.key}`, clientUpdate)
 		},
 		`tx-run:${token.key}`,
 		store,
@@ -52,8 +52,8 @@ export function syncAction<ƒ extends AtomIO.ƒn>(
 		optimisticUpdate: AtomIO.TransactionUpdate<ƒ>,
 		confirmedUpdate: AtomIO.TransactionUpdate<ƒ>,
 	) => {
-		AtomIO.setState(
-			optimisticUpdateQueueState,
+		Internal.setIntoStore(
+			optimisticUpdateQueue,
 			(queue) => {
 				queue.shift()
 				return queue
@@ -94,7 +94,7 @@ export function syncAction<ƒ extends AtomIO.ƒn>(
 				subsequentOptimistic,
 			)
 			const { id, params } = subsequentOptimistic
-			AtomIO.runTransaction(token, id, store)(...params)
+			Internal.actUponStore(token, id, store)(...params)
 		}
 	}
 
@@ -120,8 +120,8 @@ export function syncAction<ƒ extends AtomIO.ƒn>(
 					(update) => update.epoch === confirmedUpdate.epoch,
 				)
 				if (hasEnqueuedOptimisticUpdate) {
-					AtomIO.setState(
-						confirmedUpdateQueueState,
+					Internal.setIntoStore(
+						confirmedUpdateQueue,
 						(queue) => {
 							queue.push(confirmedUpdate)
 							queue.sort((a, b) => a.epoch - b.epoch)
@@ -132,14 +132,15 @@ export function syncAction<ƒ extends AtomIO.ƒn>(
 				}
 			}
 		} else {
+			const continuityEpoch = Internal.getEpochNumberOfAction(token.key, store)
 			if (
-				isRootStore(store) &&
-				store.transactionMeta.epoch === confirmedUpdate.epoch - 1
+				Internal.isRootStore(store) &&
+				continuityEpoch === confirmedUpdate.epoch - 1
 			) {
 				Internal.ingestTransactionUpdate(`newValue`, confirmedUpdate, store)
 				socket.emit(`tx-ack:${token.key}`, confirmedUpdate.epoch)
-				store.transactionMeta.epoch = confirmedUpdate.epoch
-			} else if (isRootStore(store)) {
+				Internal.setEpochNumberOfAction(token.key, confirmedUpdate.epoch, store)
+			} else if (Internal.isRootStore(store)) {
 				store.logger.info(
 					`❌`,
 					`transaction`,

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

@@ -1,5 +1,5 @@
-import * as AtomIO from "atom.io"
-import type { Store } from "atom.io/internal"
+import type * as AtomIO from "atom.io"
+import { type Store, setIntoStore } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
@@ -9,7 +9,7 @@ export function syncState<J extends Json.Serializable>(
 	store: Store,
 ): () => void {
 	const setServedValue = (data: J) => {
-		AtomIO.setState(token, data, store)
+		setIntoStore(token, data, store)
 	}
 	socket.on(`value:${token.key}`, setServedValue)
 	socket.emit(`get:${token.key}`)