atom.io 0.16.2 → 0.17.0

package/realtime-server/src/realtime-action-synchronizer.ts

@@ -1,12 +1,21 @@
 import * as AtomIO from "atom.io"
-import { IMPLICIT, subscribeToTransaction } from "atom.io/internal"
+import {
+	IMPLICIT,
+	findInStore,
+	getFromStore,
+	setIntoStore,
+	subscribeToTransaction,
+} from "atom.io/internal"
 
 import type { ServerConfig } from "."
+import { usersOfSockets } from "./realtime-server-stores"
 import {
 	completeUpdateAtoms,
 	redactedUpdateSelectors,
+	socketEpochSelectors,
+	socketUnacknowledgedUpdatesSelectors,
 	transactionRedactorAtoms,
-} from "./realtime-server-store"
+} from "./realtime-server-stores/server-sync-store"
 
 export type ActionSynchronizer = ReturnType<typeof realtimeActionSynchronizer>
 export function realtimeActionSynchronizer({
@@ -19,12 +28,24 @@ export function realtimeActionSynchronizer({
 			update: AtomIO.TransactionUpdateContent[],
 		) => AtomIO.TransactionUpdateContent[],
 	): () => void {
+		const userKeyState = findInStore(
+			usersOfSockets.states.userKeyOfSocket,
+			socket.id,
+			store,
+		)
+		const userKey = getFromStore(userKeyState, store)
+		const socketUnacknowledgedUpdatesState = findInStore(
+			socketUnacknowledgedUpdatesSelectors,
+			socket.id,
+			store,
+		)
+		const socketUnacknowledgedUpdates = getFromStore(
+			socketUnacknowledgedUpdatesState,
+			store,
+		)
 		if (filter) {
-			AtomIO.setState(
-				AtomIO.findState(transactionRedactorAtoms, tx.key),
-				{ filter },
-				store,
-			)
+			const redactorState = findInStore(transactionRedactorAtoms, tx.key, store)
+			setIntoStore(redactorState, { filter }, store)
 		}
 		const fillTransactionRequest = (update: AtomIO.TransactionUpdate<ƒ>) => {
 			const performanceKey = `tx-run:${tx.key}:${update.id}`
@@ -40,32 +61,92 @@ export function realtimeActionSynchronizer({
 			)
 			store?.logger.info(`🚀`, `transaction`, tx.key, update.id, metric.duration)
 		}
+		socket.off(`tx-run:${tx.key}`, fillTransactionRequest)
 		socket.on(`tx-run:${tx.key}`, fillTransactionRequest)
 
+		let unsubscribeFromTransaction: (() => void) | undefined
 		const fillTransactionSubscriptionRequest = () => {
-			const unsubscribe = subscribeToTransaction(
+			unsubscribeFromTransaction = subscribeToTransaction(
 				tx,
 				(update) => {
-					unsubscribe()
-					const updateState = AtomIO.findState(completeUpdateAtoms, update.id)
-					AtomIO.setState(updateState, update, store)
+					const updateState = findInStore(completeUpdateAtoms, update.id, store)
+					setIntoStore(updateState, update, store)
 					const toEmit = filter
-						? AtomIO.getState(
-								AtomIO.findState(redactedUpdateSelectors, [tx.key, update.id]),
+						? getFromStore(
+								findInStore(redactedUpdateSelectors, [tx.key, update.id], store),
 								store,
 						  )
 						: update
+
+					// the problem is that only while a socket is connected can
+					// updates be set in the queue for that socket's client.
+					//
+					// we need a client session that can persist between disconnects
+					setIntoStore(
+						socketUnacknowledgedUpdatesState,
+						(updates) => {
+							if (toEmit) {
+								updates.push(toEmit)
+								updates.sort((a, b) => a.epoch - b.epoch)
+							}
+							return updates
+						},
+						store,
+					)
+
 					socket.emit(`tx-new:${tx.key}`, toEmit)
 				},
 				`tx-sub:${tx.key}:${socket.id}`,
 				store,
 			)
-			socket.on(`tx-unsub:${tx.key}`, unsubscribe)
+			socket.on(`tx-unsub:${tx.key}`, unsubscribeFromTransaction)
 		}
 		socket.on(`tx-sub:${tx.key}`, fillTransactionSubscriptionRequest)
 
+		let i = 1
+		let next = 1
+		const retry = setInterval(() => {
+			const toEmit = socketUnacknowledgedUpdates[0]
+			console.log(userKey, socketUnacknowledgedUpdates)
+			if (toEmit && i === next) {
+				socket.emit(`tx-new:${tx.key}`, toEmit)
+				next *= 2
+			}
+
+			i++
+		}, 250)
+
+		const trackClientAcknowledgement = (epoch: number) => {
+			i = 1
+			next = 1
+			const socketEpochState = findInStore(
+				socketEpochSelectors,
+				socket.id,
+				store,
+			)
+
+			setIntoStore(socketEpochState, epoch, store)
+			if (socketUnacknowledgedUpdates[0]?.epoch === epoch) {
+				setIntoStore(
+					socketUnacknowledgedUpdatesState,
+					(updates) => {
+						updates.shift()
+						return updates
+					},
+					store,
+				)
+			}
+		}
+		socket.on(`tx-ack:${tx.key}`, trackClientAcknowledgement)
+
 		return () => {
+			if (unsubscribeFromTransaction) {
+				unsubscribeFromTransaction()
+				unsubscribeFromTransaction = undefined
+			}
+			clearInterval(retry)
 			socket.off(`tx-run:${tx.key}`, fillTransactionRequest)
+			socket.off(`tx-sub:${tx.key}`, fillTransactionSubscriptionRequest)
 		}
 	}
 }

package/realtime-server/src/realtime-family-provider.ts

@@ -1,5 +1,10 @@
-import * as AtomIO from "atom.io"
-import { IMPLICIT, subscribeToState } from "atom.io/internal"
+import type * as AtomIO from "atom.io"
+import {
+	IMPLICIT,
+	findInStore,
+	getFromStore,
+	subscribeToState,
+} from "atom.io/internal"
 import type { Json } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 
@@ -39,13 +44,13 @@ export function realtimeFamilyProvider({
 
 		const fillSubRequest = (subKey?: K) => {
 			if (subKey === undefined) {
-				const keys = AtomIO.getState(index, store)
+				const keys = getFromStore(index, store)
 				for (const key of keys) {
-					const token = AtomIO.findInStore(family, key, store)
+					const token = findInStore(family, key, store)
 					socket.emit(
 						`serve:${family.key}`,
 						parseJson(token.family?.subKey || `null`),
-						AtomIO.getState(token, store),
+						getFromStore(token, store),
 					)
 				}
 
@@ -72,7 +77,7 @@ export function realtimeFamilyProvider({
 				socket.on(`unsub:${family.key}`, fillFamilyUnsubRequest)
 			} else {
 				const token = family(subKey)
-				socket.emit(`serve:${token.key}`, AtomIO.getState(token, store))
+				socket.emit(`serve:${token.key}`, getFromStore(token, store))
 				const unsubscribe = subscribeToState(
 					token,
 					({ newValue }) => {

package/realtime-server/src/realtime-mutable-family-provider.ts

@@ -1,7 +1,9 @@
-import * as AtomIO from "atom.io"
+import type * as AtomIO from "atom.io"
 import type { Transceiver } from "atom.io/internal"
 import {
 	IMPLICIT,
+	findInStore,
+	getFromStore,
 	getJsonToken,
 	getUpdateToken,
 	subscribeToState,
@@ -48,15 +50,15 @@ export function realtimeMutableFamilyProvider({
 
 		const fillSubRequest = (subKey?: K) => {
 			if (subKey === undefined) {
-				const keys = AtomIO.getState(index, store)
+				const keys = getFromStore(index, store)
 				for (const key of keys) {
-					const token = family(key)
+					const token = findInStore(family, key, store)
 					const jsonToken = getJsonToken(token)
 					const trackerToken = getUpdateToken(token)
 					socket.emit(
 						`init:${family.key}`,
 						parseJson(jsonToken.family?.subKey || `null`),
-						AtomIO.getState(jsonToken, store),
+						getFromStore(jsonToken, store),
 					)
 					const unsubFromUpdates = subscribeToState(
 						trackerToken,
@@ -80,7 +82,7 @@ export function realtimeMutableFamilyProvider({
 						socket.emit(
 							`init:${family.key}`,
 							parseJson(jsonToken.family?.subKey || `null`),
-							AtomIO.getState(jsonToken, store),
+							getFromStore(jsonToken, store),
 						)
 						const unsubFromUpdates = subscribeToState(
 							trackerToken,
@@ -104,7 +106,7 @@ export function realtimeMutableFamilyProvider({
 				const token = family(subKey)
 				const jsonToken = getJsonToken(token)
 				const updateToken = getUpdateToken(token)
-				socket.emit(`init:${token.key}`, AtomIO.getState(jsonToken, store))
+				socket.emit(`init:${token.key}`, getFromStore(jsonToken, store))
 				const unsubscribe = subscribeToState(
 					updateToken,
 					({ newValue }) => {

package/realtime-server/src/realtime-mutable-provider.ts

@@ -1,6 +1,7 @@
-import * as AtomIO from "atom.io"
+import type * as AtomIO from "atom.io"
 import {
 	IMPLICIT,
+	getFromStore,
 	getJsonToken,
 	getUpdateToken,
 	subscribeToState,
@@ -31,7 +32,7 @@ export function realtimeMutableProvider({
 		}
 
 		const fillSubRequest = () => {
-			socket.emit(`init:${token.key}`, AtomIO.getState(jsonToken, store))
+			socket.emit(`init:${token.key}`, getFromStore(jsonToken, store))
 			unsubscribeFromStateUpdates = subscribeToState(
 				trackerToken,
 				({ newValue }) => {

package/realtime-server/src/realtime-server-stores/index.ts

@@ -0,0 +1,2 @@
+export * from "./server-user-store"
+export * from "./server-sync-store"

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

@@ -0,0 +1,115 @@
+import type { TransactionUpdate, TransactionUpdateContent } from "atom.io"
+import { atomFamily, selectorFamily } from "atom.io"
+import { SyncGroup } from "~/packages/atom.io/__unstable__/realtime-server-next/create-realtime-sync-group"
+import { usersOfSockets } from "./server-user-store"
+
+export const completeUpdateAtoms = atomFamily<
+	TransactionUpdate<any> | null,
+	string
+>({
+	key: `completeUpdate`,
+	default: null,
+})
+
+export const transactionRedactorAtoms = atomFamily<
+	{
+		filter: (updates: TransactionUpdateContent[]) => TransactionUpdateContent[]
+	},
+	string
+>({
+	key: `transactionRedactor`,
+	default: { filter: (updates) => updates },
+})
+export const redactedUpdateSelectors = selectorFamily<
+	TransactionUpdate<any> | null,
+	[transactionKey: string, updateId: string]
+>({
+	key: `redactedUpdate`,
+	get:
+		([transactionKey, updateId]) =>
+		({ get, find }) => {
+			const update = get(find(completeUpdateAtoms, updateId))
+			const { filter } = get(find(transactionRedactorAtoms, transactionKey))
+
+			if (update && filter) {
+				return { ...update, updates: filter(update.updates) }
+			}
+			return null
+		},
+})
+
+export const userUnacknowledgedUpdatesAtoms = atomFamily<
+	TransactionUpdate<any>[],
+	string
+>({
+	key: `unacknowledgedUpdates`,
+	default: () => [],
+})
+
+export const socketUnacknowledgedUpdatesSelectors = selectorFamily<
+	TransactionUpdate<any>[],
+	string
+>({
+	key: `socketUnacknowledgedUpdates`,
+	get:
+		(socketId) =>
+		({ get, find }) => {
+			const userKeyState = find(usersOfSockets.states.userKeyOfSocket, socketId)
+			const userKey = get(userKeyState)
+			if (!userKey) {
+				return []
+			}
+			const unacknowledgedUpdatesState = find(
+				userUnacknowledgedUpdatesAtoms,
+				userKey,
+			)
+			const unacknowledgedUpdates = get(unacknowledgedUpdatesState)
+			return unacknowledgedUpdates
+		},
+	set:
+		(socketId) =>
+		({ set, get, find }, newUpdates) => {
+			const userKeyState = find(usersOfSockets.states.userKeyOfSocket, socketId)
+			const userKey = get(userKeyState)
+			if (!userKey) {
+				return
+			}
+			const unacknowledgedUpdatesState = find(
+				userUnacknowledgedUpdatesAtoms,
+				userKey,
+			)
+			set(unacknowledgedUpdatesState, newUpdates)
+		},
+})
+
+export const userEpochAtoms = atomFamily<number | null, string>({
+	key: `clientEpoch`,
+	default: null,
+})
+
+export const socketEpochSelectors = selectorFamily<number | null, string>({
+	key: `socketEpoch`,
+	get:
+		(socketId) =>
+		({ get, find }) => {
+			const userKeyState = find(usersOfSockets.states.userKeyOfSocket, socketId)
+			const userKey = get(userKeyState)
+			if (!userKey) {
+				return null
+			}
+			const userEpochState = find(userEpochAtoms, userKey)
+			const userEpoch = get(userEpochState)
+			return userEpoch
+		},
+	set:
+		(socketId) =>
+		({ set, get, find }, newEpoch) => {
+			const userKeyState = find(usersOfSockets.states.userKeyOfSocket, socketId)
+			const userKey = get(userKeyState)
+			if (!userKey) {
+				return
+			}
+			const userEpochState = find(userEpochAtoms, userKey)
+			set(userEpochState, newEpoch)
+		},
+})

package/realtime-server/src/realtime-server-stores/server-user-store.ts

@@ -0,0 +1,45 @@
+import { atom, atomFamily } from "atom.io"
+import { join } from "atom.io/data"
+import { SetRTX } from "atom.io/transceivers/set-rtx"
+
+export const userIndex = atom({
+	key: `usersIndex`,
+	mutable: true,
+	default: () => new SetRTX<string>(),
+	toJson: (set) => set.toJSON(),
+	fromJson: (json) => SetRTX.fromJSON(json),
+})
+export const usersOfSockets = join({
+	key: `usersOfSockets`,
+	between: [`user`, `socket`],
+	cardinality: `1:1`,
+})
+
+export const roomIndex = atom({
+	key: `conclaveIndex`,
+	default: () => new SetRTX<string>(),
+	mutable: true,
+	toJson: (set) => set.toJSON(),
+	fromJson: (json) => SetRTX.fromJSON(json),
+})
+export type UserInRoomMeta = {
+	enteredAtEpoch: number
+}
+export const DEFAULT_USER_IN_ROOM_META: UserInRoomMeta = {
+	enteredAtEpoch: 0,
+}
+export const usersInRooms = join(
+	{
+		key: `usersInRooms`,
+		between: [`room`, `user`],
+		cardinality: `1:n`,
+	},
+	DEFAULT_USER_IN_ROOM_META,
+)
+
+// export const roomStoreAtoms = atomFamily<
+// 	{ [key: string]: any },
+// 	{ conclave: string }
+// >({
+
+// })

package/realtime-server/src/realtime-state-provider.ts

@@ -1,5 +1,5 @@
-import * as AtomIO from "atom.io"
-import { IMPLICIT, subscribeToState } from "atom.io/internal"
+import type * as AtomIO from "atom.io"
+import { IMPLICIT, getFromStore, subscribeToState } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 
 import type { ServerConfig } from "."
@@ -12,16 +12,11 @@ export function realtimeStateProvider({
 	return function stateProvider<J extends Json.Serializable>(
 		token: AtomIO.WritableToken<J>,
 	): () => void {
-		let unsubscribeFromStateUpdates: (() => void) | null = null
-
-		const fillUnsubRequest = () => {
-			socket.off(`unsub:${token.key}`, fillUnsubRequest)
-			unsubscribeFromStateUpdates?.()
-			unsubscribeFromStateUpdates = null
-		}
+		let unsubscribeFromStateUpdates: (() => void) | undefined
 
 		const fillSubRequest = () => {
-			socket.emit(`serve:${token.key}`, AtomIO.getState(token, store))
+			socket.emit(`serve:${token.key}`, getFromStore(token, store))
+
 			unsubscribeFromStateUpdates = subscribeToState(
 				token,
 				({ newValue }) => {
@@ -30,6 +25,15 @@ export function realtimeStateProvider({
 				`expose-single:${socket.id}`,
 				store,
 			)
+
+			const fillUnsubRequest = () => {
+				socket.off(`unsub:${token.key}`, fillUnsubRequest)
+				if (unsubscribeFromStateUpdates) {
+					unsubscribeFromStateUpdates()
+					unsubscribeFromStateUpdates = undefined
+				}
+			}
+
 			socket.on(`unsub:${token.key}`, fillUnsubRequest)
 		}
 
@@ -37,7 +41,10 @@ export function realtimeStateProvider({
 
 		return () => {
 			socket.off(`sub:${token.key}`, fillSubRequest)
-			unsubscribeFromStateUpdates?.()
+			if (unsubscribeFromStateUpdates) {
+				unsubscribeFromStateUpdates()
+				unsubscribeFromStateUpdates = undefined
+			}
 		}
 	}
 }

package/realtime-server/src/realtime-state-receiver.ts

@@ -1,6 +1,6 @@
 import { setState } from "atom.io"
 import type { WritableToken } from "atom.io"
-import { IMPLICIT } from "atom.io/internal"
+import { IMPLICIT, setIntoStore } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 
 import type { ServerConfig } from "."
@@ -13,7 +13,7 @@ export function realtimeStateReceiver({
 	return function stateReceiver<J extends Json.Serializable>(
 		token: WritableToken<J>,
 	): () => void {
-		const publish = (newValue: J) => setState(token, newValue, store)
+		const publish = (newValue: J) => setIntoStore(token, newValue, store)
 
 		const fillPubUnclaim = () => {
 			socket.off(`pub:${token.key}`, publish)

package/realtime-server/src/realtime-state-synchronizer.ts

@@ -0,0 +1,23 @@
+import type * as AtomIO from "atom.io"
+import { IMPLICIT, getFromStore } from "atom.io/internal"
+import type { Json } from "atom.io/json"
+
+import type { ServerConfig } from "."
+
+export function realtimeStateSynchronizer({
+	socket,
+	store = IMPLICIT.STORE,
+}: ServerConfig) {
+	return function stateSynchronizer<J extends Json.Serializable>(
+		token: AtomIO.WritableToken<J>,
+	): () => void {
+		const fillGetRequest = () => {
+			socket.emit(`value:${token.key}`, getFromStore(token, store))
+		}
+
+		socket.on(`get:${token.key}`, fillGetRequest)
+		return () => {
+			socket.off(`get:${token.key}`, fillGetRequest)
+		}
+	}
+}

package/realtime-testing/dist/index.cjs

@@ -6,6 +6,7 @@ var AtomIO = require('atom.io');
 var Internal = require('atom.io/internal');
 var AR = require('atom.io/react');
 var RTR = require('atom.io/realtime-react');
+var RTS = require('atom.io/realtime-server');
 var Happy = require('happy-dom');
 var SocketIO = require('socket.io');
 var socket_ioClient = require('socket.io-client');
@@ -34,6 +35,7 @@ var AtomIO__namespace = /*#__PURE__*/_interopNamespace(AtomIO);
 var Internal__namespace = /*#__PURE__*/_interopNamespace(Internal);
 var AR__namespace = /*#__PURE__*/_interopNamespace(AR);
 var RTR__namespace = /*#__PURE__*/_interopNamespace(RTR);
+var RTS__namespace = /*#__PURE__*/_interopNamespace(RTS);
 var Happy__namespace = /*#__PURE__*/_interopNamespace(Happy);
 var SocketIO__namespace = /*#__PURE__*/_interopNamespace(SocketIO);
 
@@ -60,13 +62,41 @@ var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 // ../anvl/src/object/entries.ts
 var recordToEntries = (obj) => Object.entries(obj);
 var setupRealtimeTestServer = (options) => {
+  const silo = new AtomIO__namespace.Silo(`SERVER`, Internal__namespace.IMPLICIT.STORE);
   const httpServer = http__namespace.createServer((_, res) => res.end(`Hello World!`));
   const address = httpServer.listen().address();
   const port = typeof address === `string` ? 80 : address === null ? null : address.port;
   if (port === null)
     throw new Error(`Could not determine port for test server`);
-  const server = new SocketIO__namespace.Server(httpServer);
-  const silo = new AtomIO__namespace.Silo(`SERVER`, Internal__namespace.IMPLICIT.STORE);
+  const server = new SocketIO__namespace.Server(httpServer).use((socket, next) => {
+    const { token, username } = socket.handshake.auth;
+    if (token === `test` && socket.id) {
+      const socketRelatedKeysState = Internal__namespace.findInStore(
+        RTS__namespace.usersOfSockets.core.findRelatedKeysState,
+        socket.id,
+        silo.store
+      );
+      const clientRelatedKeysState = Internal__namespace.findInStore(
+        RTS__namespace.usersOfSockets.core.findRelatedKeysState,
+        username,
+        silo.store
+      );
+      Internal__namespace.setIntoStore(
+        socketRelatedKeysState,
+        (keys) => (keys.clear(), keys.add(username)),
+        silo.store
+      );
+      Internal__namespace.setIntoStore(
+        clientRelatedKeysState,
+        (keys) => (keys.clear(), keys.add(socket.id)),
+        silo.store
+      );
+      console.log(`${username} connected on ${socket.id}`);
+      next();
+    } else {
+      next(new Error(`Authentication error`));
+    }
+  });
   server.on(`connection`, (socket) => {
     options.server({ socket, silo });
   });
@@ -82,32 +112,41 @@ var setupRealtimeTestServer = (options) => {
   };
 };
 var setupRealtimeTestClient = (options, name, port) => {
-  const socket = socket_ioClient.io(`http://localhost:${port}/`);
-  const silo = new AtomIO__namespace.Silo(name, Internal__namespace.IMPLICIT.STORE);
-  const { document } = new Happy__namespace.Window();
-  document.body.innerHTML = `<div id="app"></div>`;
-  const renderResult = react.render(
-    /* @__PURE__ */ jsxRuntime.jsx(AR__namespace.StoreProvider, { store: silo.store, children: /* @__PURE__ */ jsxRuntime.jsx(RTR__namespace.RealtimeProvider, { socket, children: /* @__PURE__ */ jsxRuntime.jsx(options.client, {}) }) }),
-    {
-      container: document.querySelector(`#app`)
+  const testClient = { dispose: () => {
+  } };
+  const init = () => {
+    const socket = socket_ioClient.io(`http://localhost:${port}/`, {
+      auth: { token: `test`, username: name }
+    });
+    const silo = new AtomIO__namespace.Silo(name, Internal__namespace.IMPLICIT.STORE);
+    for (const [key, value] of silo.store.valueMap.entries()) {
+      if (Array.isArray(value)) {
+        silo.store.valueMap.set(key, [...value]);
+      }
     }
-  );
-  const prettyPrint = () => console.log(react.prettyDOM(renderResult.container));
-  const disconnect = () => socket.disconnect();
-  const reconnect = () => socket.connect();
-  const dispose = () => {
-    socket.disconnect();
-    Internal__namespace.clearStore(silo.store);
-  };
-  return {
-    name,
-    silo,
-    renderResult,
-    prettyPrint,
-    disconnect,
-    reconnect,
-    dispose
+    const { document } = new Happy__namespace.Window();
+    document.body.innerHTML = `<div id="app"></div>`;
+    const renderResult = react.render(
+      /* @__PURE__ */ jsxRuntime.jsx(AR__namespace.StoreProvider, { store: silo.store, children: /* @__PURE__ */ jsxRuntime.jsx(RTR__namespace.RealtimeProvider, { socket, children: /* @__PURE__ */ jsxRuntime.jsx(options.client, {}) }) }),
+      {
+        container: document.querySelector(`#app`)
+      }
+    );
+    const prettyPrint = () => console.log(react.prettyDOM(renderResult.container));
+    const dispose = () => {
+      socket.disconnect();
+      Internal__namespace.clearStore(silo.store);
+    };
+    testClient.dispose = dispose;
+    return {
+      name,
+      silo,
+      socket,
+      renderResult,
+      prettyPrint
+    };
   };
+  return Object.assign(testClient, { init });
 };
 var singleClient = (options) => {
   const server = setupRealtimeTestServer(options);