atom.io 0.30.2 → 0.30.4

package/realtime-server/src/continuity/prepare-to-serve-transaction-request.ts

@@ -0,0 +1,53 @@
+import type { TransactionUpdate } from "atom.io"
+import type { Store } from "atom.io/internal"
+import { actUponStore } from "atom.io/internal"
+import type { JsonIO } from "atom.io/json"
+import type { ContinuityToken } from "atom.io/realtime"
+
+export function prepareToServeTransactionRequest(
+	store: Store,
+	continuity: ContinuityToken,
+	userKey: string,
+): (update: Pick<TransactionUpdate<JsonIO>, `id` | `key` | `params`>) => void {
+	const continuityKey = continuity.key
+	return function serveTransactionRequest(update) {
+		store.logger.info(`🛎️`, `continuity`, continuityKey, `received`, update)
+		const transactionKey = update.key
+		const updateId = update.id
+		const performanceKey = `tx-run:${transactionKey}:${updateId}`
+		const performanceKeyStart = `${performanceKey}:start`
+		const performanceKeyEnd = `${performanceKey}:end`
+		performance.mark(performanceKeyStart)
+		try {
+			actUponStore(
+				{ type: `transaction`, key: transactionKey },
+				updateId,
+				store,
+			)(...update.params)
+		} catch (thrown) {
+			if (thrown instanceof Error) {
+				store.logger.error(
+					`❌`,
+					`continuity`,
+					continuityKey,
+					`failed to run transaction ${transactionKey} from ${userKey} with update ${updateId}`,
+					thrown.message,
+				)
+			}
+		}
+		performance.mark(performanceKeyEnd)
+		const metric = performance.measure(
+			performanceKey,
+			performanceKeyStart,
+			performanceKeyEnd,
+		)
+		store?.logger.info(
+			`🚀`,
+			`transaction`,
+			transactionKey,
+			updateId,
+			userKey,
+			metric.duration,
+		)
+	}
+}

package/realtime-server/src/continuity/prepare-to-sync-realtime-continuity.ts

@@ -0,0 +1,145 @@
+import { findRelationsInStore } from "atom.io/data"
+import {
+	findInStore,
+	getFromStore,
+	IMPLICIT,
+	subscribeToState,
+} from "atom.io/internal"
+import type { Json } from "atom.io/json"
+import type { ContinuityToken } from "atom.io/realtime"
+
+import type { ServerConfig, Socket } from ".."
+import { socketAtoms, usersOfSockets } from ".."
+import { userUnacknowledgedQueues } from "../realtime-server-stores"
+import { prepareToSendInitialPayload } from "./prepare-to-send-initial-payload"
+import { prepareToServeTransactionRequest } from "./prepare-to-serve-transaction-request"
+import { prepareToTrackClientAcknowledgement } from "./prepare-to-track-client-acknowledgement"
+import { subscribeToContinuityActions } from "./subscribe-to-continuity-actions"
+import { subscribeToContinuityPerspectives } from "./subscribe-to-continuity-perpectives"
+
+export type ExposeRealtimeContinuity = (
+	continuity: ContinuityToken,
+) => () => void
+export function prepareToExposeRealtimeContinuity({
+	socket: initialSocket,
+	store = IMPLICIT.STORE,
+}: ServerConfig): ExposeRealtimeContinuity {
+	return function syncRealtimeContinuity(continuity) {
+		let socket: Socket | null = initialSocket
+
+		const continuityKey = continuity.key
+		const userKeyState = findRelationsInStore(
+			usersOfSockets,
+			`socket::${socket.id}`,
+			store,
+		).userKeyOfSocket
+		const userKey = getFromStore(store, userKeyState)
+		if (!userKey) {
+			store.logger.error(
+				`❌`,
+				`continuity`,
+				continuityKey,
+				`Tried to create a synchronizer for a socket (${socket.id}) that is not connected to a user.`,
+			)
+			return () => {}
+		}
+
+		const socketKeyState = findRelationsInStore(
+			usersOfSockets,
+			userKey,
+			store,
+		).socketKeyOfUser
+		const unsubscribeFromSocketTracking = subscribeToState(
+			socketKeyState,
+			({ newValue: newSocketKey }) => {
+				store.logger.info(
+					`👋`,
+					`continuity`,
+					continuityKey,
+					`seeing ${userKey} on new socket ${newSocketKey}`,
+				)
+				if (newSocketKey === null) {
+					store.logger.warn(
+						`❌`,
+						`continuity`,
+						continuityKey,
+						`User (${userKey}) is not connected to a socket, waiting for them to reappear.`,
+					)
+					return
+				}
+				const newSocketState = findInStore(store, socketAtoms, newSocketKey)
+				const newSocket = getFromStore(store, newSocketState)
+				socket = newSocket
+				for (const unacknowledgedUpdate of userUnacknowledgedUpdates) {
+					socket?.emit(
+						`tx-new:${continuityKey}`,
+						unacknowledgedUpdate as Json.Serializable,
+					)
+				}
+			},
+			`sync-continuity:${continuityKey}:${userKey}`,
+			store,
+		)
+
+		const userUnacknowledgedUpdates = getFromStore(
+			store,
+			userUnacknowledgedQueues,
+			userKey,
+		)
+
+		const unsubscribeFunctions: (() => void)[] = []
+
+		const unsubscribeFromPerspectives = subscribeToContinuityPerspectives(
+			store,
+			continuity,
+			userKey,
+			socket,
+		)
+		const unsubscribeFromTransactions = subscribeToContinuityActions(
+			store,
+			continuity,
+			userKey,
+			socket,
+		)
+		unsubscribeFunctions.push(
+			...unsubscribeFromPerspectives,
+			...unsubscribeFromTransactions,
+		)
+
+		const sendInitialPayload = prepareToSendInitialPayload(
+			store,
+			continuity,
+			userKey,
+			initialSocket,
+		)
+
+		socket.off(`get:${continuityKey}`, sendInitialPayload)
+		socket.on(`get:${continuityKey}`, sendInitialPayload)
+
+		const fillTransactionRequest = prepareToServeTransactionRequest(
+			store,
+			continuity,
+			userKey,
+		)
+
+		socket.off(`tx-run:${continuityKey}`, fillTransactionRequest)
+		socket.on(`tx-run:${continuityKey}`, fillTransactionRequest)
+
+		const trackClientAcknowledgement = prepareToTrackClientAcknowledgement(
+			store,
+			continuity,
+			userKey,
+			userUnacknowledgedUpdates,
+		)
+
+		socket?.on(`ack:${continuityKey}`, trackClientAcknowledgement)
+
+		return () => {
+			// clearInterval(retryTimeout)
+			for (const unsubscribe of unsubscribeFunctions) unsubscribe()
+			socket?.off(`ack:${continuityKey}`, trackClientAcknowledgement)
+			socket?.off(`get:${continuityKey}`, sendInitialPayload)
+			socket?.off(`tx-run:${continuityKey}`, fillTransactionRequest)
+		}
+	}
+}

package/realtime-server/src/continuity/prepare-to-track-client-acknowledgement.ts

@@ -0,0 +1,38 @@
+import type { Store } from "atom.io/internal"
+import { setIntoStore } from "atom.io/internal"
+import type { ContinuityToken } from "atom.io/realtime"
+
+import type { ContinuitySyncTransactionUpdate } from "../realtime-server-stores"
+import { userUnacknowledgedQueues } from "../realtime-server-stores"
+
+export function prepareToTrackClientAcknowledgement(
+	store: Store,
+	continuity: ContinuityToken,
+	userKey: string,
+	userUnacknowledgedUpdates: ContinuitySyncTransactionUpdate[],
+): (epoch: number) => void {
+	const continuityKey = continuity.key
+	return function trackClientAcknowledgement(epoch) {
+		store.logger.info(
+			`👍`,
+			`continuity`,
+			continuityKey,
+			`${userKey} acknowledged epoch ${epoch}`,
+		)
+		const isUnacknowledged = userUnacknowledgedUpdates[0]?.epoch === epoch
+		if (isUnacknowledged) {
+			setIntoStore(store, userUnacknowledgedQueues, userKey, (updates) => {
+				updates.shift()
+				store.logger.info(
+					`👍`,
+					`continuity`,
+					continuityKey,
+					`${userKey} unacknowledged update queue now has`,
+					updates.length,
+					`items`,
+				)
+				return updates
+			})
+		}
+	}
+}

package/realtime-server/src/continuity/subscribe-to-continuity-actions.ts

@@ -0,0 +1,106 @@
+import type { Store } from "atom.io/internal"
+import {
+	findInStore,
+	getFromStore,
+	getJsonToken,
+	getUpdateToken,
+	isRootStore,
+	setIntoStore,
+	subscribeToTransaction,
+} from "atom.io/internal"
+import type { Json } from "atom.io/json"
+import type { ContinuityToken } from "atom.io/realtime"
+
+import type { Socket, UserKey } from ".."
+import {
+	redactTransactionUpdateContent,
+	userUnacknowledgedQueues,
+} from "../realtime-server-stores"
+
+export function subscribeToContinuityActions(
+	store: Store,
+	continuity: ContinuityToken,
+	userKey: UserKey,
+	socket: Socket | null,
+): (() => void)[] {
+	const continuityKey = continuity.key
+	const unsubscribeFunctions: (() => void)[] = []
+
+	for (const transaction of continuity.actions) {
+		const unsubscribeFromTransaction = subscribeToTransaction(
+			transaction,
+			(update) => {
+				try {
+					const visibleKeys = continuity.globals
+						.map((atom) => {
+							if (atom.type === `atom`) {
+								return atom.key
+							}
+							return getUpdateToken(atom).key
+						})
+						.concat(
+							continuity.perspectives.flatMap((perspective) => {
+								const { viewAtoms } = perspective
+								const userPerspectiveTokenState = findInStore(
+									store,
+									viewAtoms,
+									userKey,
+								)
+								const visibleTokens = getFromStore(
+									store,
+									userPerspectiveTokenState,
+								)
+								return visibleTokens.map((token) => {
+									const key =
+										token.type === `mutable_atom` ? `*` + token.key : token.key
+									return key
+								})
+							}),
+						)
+					const redactedUpdates = redactTransactionUpdateContent(
+						visibleKeys,
+						update.updates,
+					)
+					const redactedUpdate = {
+						...update,
+						updates: redactedUpdates,
+					}
+					setIntoStore(store, userUnacknowledgedQueues, userKey, (updates) => {
+						if (redactedUpdate) {
+							updates.push(redactedUpdate)
+							updates.sort((a, b) => a.epoch - b.epoch)
+							store.logger.info(
+								`👍`,
+								`continuity`,
+								continuityKey,
+								`${userKey} unacknowledged update queue now has`,
+								updates.length,
+								`items`,
+							)
+						}
+						return updates
+					})
+
+					socket?.emit(
+						`tx-new:${continuityKey}`,
+						redactedUpdate as Json.Serializable,
+					)
+				} catch (thrown) {
+					if (thrown instanceof Error) {
+						store.logger.error(
+							`❌`,
+							`continuity`,
+							continuityKey,
+							`${userKey} failed to send update from transaction ${transaction.key} to ${userKey}`,
+							thrown.message,
+						)
+					}
+				}
+			},
+			`sync-continuity:${continuityKey}:${userKey}`,
+			store,
+		)
+		unsubscribeFunctions.push(unsubscribeFromTransaction)
+	}
+	return unsubscribeFunctions
+}

package/realtime-server/src/continuity/subscribe-to-continuity-perpectives.ts

@@ -0,0 +1,60 @@
+import type { Store } from "atom.io/internal"
+import {
+	findInStore,
+	getFromStore,
+	getJsonToken,
+	subscribeToState,
+} from "atom.io/internal"
+import type { ContinuityToken } from "atom.io/realtime"
+
+import type { Socket } from ".."
+import type { UserKey } from "../realtime-server-stores"
+
+export function subscribeToContinuityPerspectives(
+	store: Store,
+	continuity: ContinuityToken,
+	userKey: UserKey,
+	socket: Socket | null,
+): (() => void)[] {
+	const continuityKey = continuity.key
+	const unsubFns: (() => void)[] = []
+	for (const perspective of continuity.perspectives) {
+		const { viewAtoms } = perspective
+		const userViewState = findInStore(store, viewAtoms, userKey)
+		const unsubscribeFromUserView = subscribeToState(
+			userViewState,
+			({ oldValue, newValue }) => {
+				const oldKeys = oldValue.map((token) => token.key)
+				const newKeys = newValue.map((token) => token.key)
+				const concealed = oldValue.filter(
+					(token) => !newKeys.includes(token.key),
+				)
+				const revealed = newValue
+					.filter((token) => !oldKeys.includes(token.key))
+					.flatMap((token) => {
+						const resourceToken =
+							token.type === `mutable_atom` ? getJsonToken(store, token) : token
+						const resource = getFromStore(store, resourceToken)
+						return [resourceToken, resource]
+					})
+				store.logger.info(
+					`👁`,
+					`atom`,
+					perspective.resourceAtoms.key,
+					`${userKey} has a new perspective`,
+					{ oldKeys, newKeys, revealed, concealed },
+				)
+				if (revealed.length > 0) {
+					socket?.emit(`reveal:${continuityKey}`, revealed)
+				}
+				if (concealed.length > 0) {
+					socket?.emit(`conceal:${continuityKey}`, concealed)
+				}
+			},
+			`sync-continuity:${continuityKey}:${userKey}:perspective:${perspective.resourceAtoms.key}`,
+			store,
+		)
+		unsubFns.push(unsubscribeFromUserView)
+	}
+	return unsubFns
+}

package/realtime-server/src/index.ts

@@ -1,9 +1,9 @@
 import type { Store } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 
+export * from "./continuity/prepare-to-sync-realtime-continuity"
 export * from "./ipc-sockets"
 export * from "./realtime-action-receiver"
-export * from "./realtime-continuity-synchronizer"
 export * from "./realtime-family-provider"
 export * from "./realtime-mutable-family-provider"
 export * from "./realtime-mutable-provider"

package/realtime-server/src/ipc-sockets/child-socket.ts

@@ -65,7 +65,7 @@ export class ChildSocket<
 			<Event extends keyof I>(buffer: EventBuffer<string, I[Event]>) => {
 				const chunk = buffer.toString()
 
-				if (chunk === `✨`) {
+				if (chunk === `ALIVE`) {
 					// console.log(chunk)
 					return
 				}

package/realtime-server/src/ipc-sockets/parent-socket.ts

@@ -180,7 +180,7 @@ export class ParentSocket<
 			}
 		})
 
-		process.stdout.write(`✨`)
+		process.stdout.write(`ALIVE`)
 	}
 
 	public relay(

package/realtime-server/src/realtime-server-stores/server-room-external-store.ts

@@ -30,7 +30,7 @@ export const roomSelectors = selectorFamily<
 				(resolve) => {
 					const room = spawn(script, options, { env: process.env })
 					const resolver = (data: Buffer) => {
-						if (data.toString() === `✨`) {
+						if (data.toString() === `ALIVE`) {
 							room.stdout.off(`data`, resolver)
 							resolve(room)
 						}

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

@@ -1,6 +1,8 @@
 import type { TransactionUpdate, TransactionUpdateContent } from "atom.io"
 import { atomFamily } from "atom.io"
 
+import type { UserKey } from "./server-user-store"
+
 // export const completeUpdateAtoms = atomFamily<
 // 	TransactionUpdate<any> | null,
 // 	string
@@ -42,13 +44,13 @@ export function redactTransactionUpdateContent(
 		})
 }
 
-export const actionOcclusionAtoms = atomFamily<
+export const redactorAtoms = atomFamily<
 	{
 		occlude: (updates: TransactionUpdateContent[]) => TransactionUpdateContent[]
 	},
-	string
+	UserKey
 >({
-	key: `transactionRedactor`,
+	key: `redactor`,
 	default: { occlude: (updates) => updates },
 })
 // export const redactedUpdateSelectors = selectorFamily<
@@ -69,9 +71,13 @@ export const actionOcclusionAtoms = atomFamily<
 // 		},
 // })
 
+export type ContinuitySyncTransactionUpdate = Pick<
+	TransactionUpdate<any>,
+	`epoch` | `id` | `key` | `output` | `updates`
+>
 export const userUnacknowledgedQueues = atomFamily<
-	Pick<TransactionUpdate<any>, `epoch` | `id` | `key` | `output` | `updates`>[],
-	string
+	ContinuitySyncTransactionUpdate[],
+	UserKey
 >({
 	key: `unacknowledgedUpdates`,
 	default: () => [],