atom.io 0.46.8 → 0.46.10

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

@@ -1,20 +1,23 @@
 import type * as AtomIO from "atom.io"
 import { setIntoStore, type Store } from "atom.io/internal"
 import type { Json } from "atom.io/json"
-import type { Socket } from "atom.io/realtime"
+import { employSocket, type Socket } from "atom.io/realtime"
+
+import { createSubscriber } from "./create-subscriber"
 
 export function pullAtom<J extends Json.Serializable>(
 	store: Store,
 	socket: Socket,
 	token: AtomIO.RegularAtomToken<J, any, any>,
 ): () => void {
-	const setServedValue = (data: J) => {
-		setIntoStore(store, token, data)
-	}
-	socket.on(`serve:${token.key}`, setServedValue)
-	socket.emit(`sub:${token.key}`)
-	return () => {
-		socket.off(`serve:${token.key}`, setServedValue)
-		socket.emit(`unsub:${token.key}`)
-	}
+	return createSubscriber(socket, token.key, (key) => {
+		const stopWatching = employSocket(socket, `serve:${key}`, (data: J) => {
+			setIntoStore(store, token, data)
+		})
+		socket.emit(`sub:${token.key}`)
+		return () => {
+			socket.emit(`unsub:${key}`)
+			stopWatching()
+		}
+	})
 }

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

@@ -7,7 +7,9 @@ import {
 	setIntoStore,
 } from "atom.io/internal"
 import type { Canonical } from "atom.io/json"
-import type { Socket } from "atom.io/realtime"
+import { employSocket, type Socket } from "atom.io/realtime"
+
+import { createSubscriber } from "./create-subscriber"
 
 export function pullMutableAtomFamilyMember<
 	T extends Transceiver<any, any, any>,
@@ -19,17 +21,28 @@ export function pullMutableAtomFamilyMember<
 	key: NoInfer<K>,
 ): () => void {
 	const token = findInStore(store, family, key)
-	socket.on(`init:${token.key}`, (data: AsJSON<T>) => {
-		const jsonToken = getJsonToken(store, token)
-		setIntoStore(store, jsonToken, data)
-	})
-	socket.on(`next:${token.key}`, (data: SignalFrom<T>) => {
-		const trackerToken = getUpdateToken(token)
-		setIntoStore(store, trackerToken, data)
+	const jsonToken = getJsonToken(store, token)
+	const trackerToken = getUpdateToken(token)
+	return createSubscriber(socket, token.key, () => {
+		const stopWatchingForInit = employSocket(
+			socket,
+			`init:${token.key}`,
+			(data: AsJSON<T>) => {
+				setIntoStore(store, jsonToken, data)
+			},
+		)
+		const stopWatchingForUpdate = employSocket(
+			socket,
+			`next:${token.key}`,
+			(data: SignalFrom<T>) => {
+				setIntoStore(store, trackerToken, data)
+			},
+		)
+		socket.emit(`sub:${family.key}`, key)
+		return () => {
+			socket.emit(`unsub:${token.key}`)
+			stopWatchingForInit()
+			stopWatchingForUpdate()
+		}
 	})
-	socket.emit(`sub:${family.key}`, key)
-	return () => {
-		socket.off(`serve:${token.key}`)
-		socket.emit(`unsub:${token.key}`)
-	}
 }

package/src/realtime-client/pull-mutable-atom.ts

@@ -1,7 +1,9 @@
 import type * as AtomIO from "atom.io"
 import type { AsJSON, SignalFrom, Store, Transceiver } from "atom.io/internal"
 import { getJsonToken, getUpdateToken, setIntoStore } from "atom.io/internal"
-import type { Socket } from "atom.io/realtime"
+import { employSocket, type Socket } from "atom.io/realtime"
+
+import { createSubscriber } from "./create-subscriber"
 
 export function pullMutableAtom<T extends Transceiver<any, any, any>>(
 	store: Store,
@@ -10,16 +12,26 @@ export function pullMutableAtom<T extends Transceiver<any, any, any>>(
 ): () => void {
 	const jsonToken = getJsonToken(store, token)
 	const updateToken = getUpdateToken(token)
-	socket.on(`init:${token.key}`, (data: AsJSON<T>) => {
-		setIntoStore(store, jsonToken, data)
-	})
-	socket.on(`next:${token.key}`, (data: SignalFrom<T>) => {
-		setIntoStore(store, updateToken, data)
+	return createSubscriber(socket, token.key, () => {
+		const stopWatchingForInit = employSocket(
+			socket,
+			`init:${token.key}`,
+			(data: AsJSON<T>) => {
+				setIntoStore(store, jsonToken, data)
+			},
+		)
+		const stopWatchingForUpdate = employSocket(
+			socket,
+			`next:${token.key}`,
+			(data: SignalFrom<T>) => {
+				setIntoStore(store, updateToken, data)
+			},
+		)
+		socket.emit(`sub:${token.key}`)
+		return () => {
+			socket.emit(`unsub:${token.key}`)
+			stopWatchingForInit()
+			stopWatchingForUpdate()
+		}
 	})
-	socket.emit(`sub:${token.key}`)
-	return () => {
-		socket.off(`init:${token.key}`)
-		socket.off(`next:${token.key}`)
-		socket.emit(`unsub:${token.key}`)
-	}
 }

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

@@ -15,10 +15,6 @@ export function pullSelectorRoots(
 	selectorToken: SelectorToken<any>,
 ): () => void {
 	const atomSubscriptions = new Map<string, () => void>()
-	const clearAtomSubscriptions = () => {
-		for (const [, unsub] of atomSubscriptions) unsub()
-		atomSubscriptions.clear()
-	}
 
 	const start = () => {
 		const atomKeys = store.selectorAtoms.getRelatedKeys(selectorToken.key)
@@ -84,7 +80,7 @@ export function pullSelectorRoots(
 	start()
 
 	return () => {
-		clearAtomSubscriptions()
+		for (const [, unsub] of atomSubscriptions) unsub()
 		unsubFromSelector()
 	}
 }

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

@@ -5,43 +5,32 @@ import type { Json } from "atom.io/json"
 import type { Socket } from "atom.io/realtime"
 import { employSocket, mutexAtoms } from "atom.io/realtime"
 
+import { createSubscriber } from "./create-subscriber"
+
 export function pushState<J extends Json.Serializable>(
 	store: Store,
 	socket: Socket,
 	token: WritableToken<J>,
 ): () => void {
-	const publish = (newValue: J) => {
-		socket.emit(`pub:${token.key}`, newValue)
-	}
-
-	const subscriptions = new Set<() => void>()
-	const clearSubscriptions = () => {
-		for (const unsub of subscriptions) unsub()
-		subscriptions.clear()
-	}
-
-	const init = () => {
-		subscriptions.add(
-			employSocket(socket, `claim-result:${token.key}`, (success: boolean) => {
+	return createSubscriber(socket, `push:${token.key}`, () => {
+		let stopWatching = employSocket(
+			socket,
+			`claim-result:${token.key}`,
+			(success: boolean) => {
 				if (!success) return
-
-				clearSubscriptions()
+				stopWatching()
 				setIntoStore(store, mutexAtoms, token.key, true)
-				subscriptions.add(
-					subscribeToState(store, token, `push`, ({ newValue }) => {
-						publish(newValue)
-					}),
-				)
-			}),
+				stopWatching = subscribeToState(store, token, `push`, ({ newValue }) => {
+					socket.emit(`pub:${token.key}`, newValue)
+				})
+			},
 		)
 
 		socket.emit(`claim:${token.key}`)
-	}
-
-	init()
 
-	return () => {
-		clearSubscriptions()
-		socket.emit(`unclaim:${token.key}`)
-	}
+		return () => {
+			socket.emit(`unclaim:${token.key}`)
+			stopWatching()
+		}
+	})
 }

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

@@ -1,5 +1,10 @@
 import * as AtomIO from "atom.io"
-import type { RoomKey, SocketKey, UserKey } from "atom.io/realtime"
+import {
+	type RoomKey,
+	type SocketKey,
+	type UserKey,
+	usersInRooms,
+} from "atom.io/realtime"
 
 export const mySocketKeyAtom: AtomIO.RegularAtomToken<SocketKey | undefined> =
 	AtomIO.atom<SocketKey | undefined>({
@@ -22,8 +27,26 @@ export const myUserKeyAtom: AtomIO.RegularAtomToken<UserKey | null> =
 		],
 	})
 
-export const myRoomKeyAtom: AtomIO.RegularAtomToken<RoomKey | null> =
-	AtomIO.atom<RoomKey | null>({
+export const myRoomKeySelector: AtomIO.ReadonlyPureSelectorToken<RoomKey | null> =
+	AtomIO.selector<RoomKey | null>({
 		key: `myRoomKey`,
-		default: null,
+		get: ({ get }) => {
+			if (
+				`env` in globalThis &&
+				`REALTIME_ROOM_KEY` in (globalThis as any).env
+			) {
+				// if a room running server-side wants its own key, this is where it lives
+				return (globalThis as any).env[`REALTIME_ROOM_KEY`]
+			}
+			const myUserKey = get(myUserKeyAtom)
+			if (!myUserKey) return null
+			const [, usersInRoomsAtoms] = AtomIO.getInternalRelations(
+				usersInRooms,
+				`split`,
+			)
+			const roomKeys = get(usersInRoomsAtoms, myUserKey)
+			for (const roomKey of roomKeys) {
+				return roomKey
+			}
+		},
 	})

package/src/realtime-react/use-pull-mutable-family-member.ts

@@ -14,8 +14,8 @@ export function usePullMutableAtomFamilyMember<
 >(familyToken: AtomIO.MutableAtomFamilyToken<T, K>, key: NoInfer<K>): T {
 	const store = React.useContext(StoreContext)
 	const token = findInStore(store, familyToken, key)
-	useRealtimeService(`pull:${token.key}`, (socket) =>
-		RTC.pullMutableAtomFamilyMember(store, socket, familyToken, key),
-	)
+	useRealtimeService(`pull:${token.key}`, (socket) => {
+		return RTC.pullMutableAtomFamilyMember(store, socket, familyToken, key)
+	})
 	return useO(token)
 }

package/src/realtime-react/use-realtime-rooms.ts

@@ -3,56 +3,59 @@ import { findInStore, getInternalRelationsFromStore } from "atom.io/internal"
 import { StoreContext, useO } from "atom.io/react"
 import type { RoomKey, RoomSocketInterface, UserKey } from "atom.io/realtime"
 import { ownersOfRooms, roomKeysAtom, usersInRooms } from "atom.io/realtime"
+import { myUserKeyAtom } from "atom.io/realtime-client"
 import type { UList } from "atom.io/transceivers/u-list"
 import * as React from "react"
 import type { Socket } from "socket.io-client"
 
 import { RealtimeContext } from "./realtime-context"
+import { usePullAtom } from "./use-pull-atom"
 import { usePullMutable } from "./use-pull-mutable-atom"
 import { usePullMutableAtomFamilyMember } from "./use-pull-mutable-family-member"
 
 export type RealtimeRoomsTools = {
-	socket: Socket<{}, RoomSocketInterface<string>>
+	roomSocket: Socket<{}, RoomSocketInterface<string>>
 	myRoomKey: RoomKey | undefined
 	myMutualsAtom: MutableAtomToken<UList<UserKey>>
 	myOwnedRoomsAtom: MutableAtomToken<UList<RoomKey>>
 	allRoomKeysAtom: MutableAtomToken<UList<RoomKey>>
 }
-export function useRealtimeRooms<RoomNames extends string>(
-	userKey: UserKey,
-): RealtimeRoomsTools {
+export function useRealtimeRooms<
+	RoomNames extends string,
+>(): RealtimeRoomsTools {
 	const store = React.useContext(StoreContext)
 	const { socket } = React.useContext(RealtimeContext)
 	usePullMutable(roomKeysAtom)
+	const userKey = usePullAtom(myUserKeyAtom) ?? `user::$_NONE_$`
 
 	const [userKeysFamily, roomKeysFamily] = getInternalRelationsFromStore(
 		store,
 		usersInRooms,
 		`split`,
 	)
-
 	usePullMutableAtomFamilyMember(roomKeysFamily, userKey)
+
 	const myJoinedRoomKeys = useO(roomKeysFamily, userKey)
 	let myRoomKey: RoomKey | undefined
 	for (const roomKey of myJoinedRoomKeys) {
 		myRoomKey = roomKey
 		break
 	}
-
 	const roomKey = myRoomKey ?? `room::$_NONE_$`
 	const myMutualsAtom = findInStore(store, userKeysFamily, roomKey)
 	usePullMutableAtomFamilyMember(userKeysFamily, roomKey)
 
-	const [ownedRoomsFamily] = getInternalRelationsFromStore(
+	const [ownedRoomsFamily, roomOwnersFamily] = getInternalRelationsFromStore(
 		store,
 		ownersOfRooms,
 		`split`,
 	)
 	const myOwnedRoomsAtom = findInStore(store, ownedRoomsFamily, userKey)
 	usePullMutableAtomFamilyMember(ownedRoomsFamily, userKey)
+	usePullMutableAtomFamilyMember(roomOwnersFamily, roomKey)
 
 	return {
-		socket: socket as Socket<{}, RoomSocketInterface<RoomNames>>,
+		roomSocket: socket as Socket<{}, RoomSocketInterface<RoomNames>>,
 		myRoomKey,
 		allRoomKeysAtom: roomKeysAtom,
 		myMutualsAtom,

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

@@ -98,6 +98,7 @@ export class ChildSocket<
 					}
 					try {
 						const jsonPiece = parseJson(piece as stringified<EventPayload<I, K>>)
+						this.logger.info(`💸`, `emitted`, jsonPiece)
 						this.handleEvent(...jsonPiece)
 						this.incompleteData = ``
 					} catch (thrown0) {
@@ -118,6 +119,7 @@ export class ChildSocket<
 								const maybeActualJsonPiece = parseJson(
 									initialMaybeWellFormed as stringified<EventPayload<I, K>>,
 								)
+								this.logger.info(`💸`, `emitted`, maybeActualJsonPiece)
 								this.handleEvent(...maybeActualJsonPiece)
 								this.incompleteData = ``
 							} else {

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

@@ -51,7 +51,7 @@ export type ParentProcess = {
 
 export class ParentSocket<
 	I extends Events & {
-		[id in string as `relay::${id}`]: [string, ...Json.Array[]]
+		[user: UserKey]: [string, ...Json.Array[]]
 	},
 	O extends Events & {
 		[id in string as `user::${id}`]: [string, ...Json.Array[]]
@@ -65,7 +65,7 @@ export class ParentSocket<
 > extends CustomSocket<I, O> {
 	protected incompleteData = ``
 	protected unprocessedEvents: string[] = []
-	protected relays: Map<string, SubjectSocket<any, any>>
+	protected relays: Map<UserKey, SubjectSocket<any, any>>
 	protected initRelay: (
 		socket: SubjectSocket<any, any>,
 		userKey: UserKey,
@@ -177,9 +177,13 @@ export class ParentSocket<
 
 		this.on(`user-joins`, (userKey: UserKey) => {
 			this.logger.info(`👤`, userKey, `joined`)
+			const existingRelay = this.relays.get(userKey)
+			if (existingRelay) {
+				return
+			}
 			const relay = new SubjectSocket(userKey)
 			this.relays.set(userKey, relay)
-			this.logger.info(`🔗`, `attaching services for user`, userKey)
+			this.logger.info(`🔗`, `attaching relay services for`, userKey)
 			const cleanupRelay = this.initRelay(relay, userKey)
 			if (cleanupRelay) {
 				relay.disposalFunctions.push(cleanupRelay)
@@ -187,17 +191,19 @@ export class ParentSocket<
 			this.on(userKey, (...data) => {
 				relay.in.next(data)
 			})
-			relay.out.subscribe(`socket`, (data) => {
-				this.emit(...(data as [string, ...I[string & keyof I]]))
-			})
+			relay.disposalFunctions.push(
+				relay.out.subscribe(`socket`, (data) => {
+					this.emit(userKey, ...(data as any))
+				}),
+			)
 		})
 
-		this.on(`user-leaves`, (username) => {
-			const relay = this.relays.get(username)
-			this.off(`relay:${username}`)
+		this.on(`user-leaves`, (userKey: UserKey) => {
+			const relay = this.relays.get(userKey)
+			this.off(userKey)
 			if (relay) {
 				relay.dispose()
-				this.relays.delete(username)
+				this.relays.delete(userKey)
 			}
 		})
 
@@ -210,7 +216,7 @@ export class ParentSocket<
 			userKey: UserKey,
 		) => (() => void) | void,
 	): void {
-		this.logger.info(`🔗`, `running relay method`)
 		this.initRelay = attachServices
+		this.logger.info(`🔗`, `ready to relay`)
 	}
 }

package/src/realtime-server/provide-rooms.ts

@@ -32,12 +32,10 @@ import {
 	visibilityFromRoomSelector,
 	visibleUsersInRoomsSelector,
 } from "atom.io/realtime"
-import { myRoomKeyAtom } from "atom.io/realtime-client"
 
 import { ChildSocket, PROOF_OF_LIFE_SIGNAL } from "./ipc-sockets"
 import { realtimeMutableFamilyProvider } from "./realtime-mutable-family-provider"
 import { realtimeMutableProvider } from "./realtime-mutable-provider"
-import { realtimeStateProvider } from "./realtime-state-provider"
 
 export type RoomMap = Map<
 	string,
@@ -78,7 +76,9 @@ export function spawnRoom<RoomNames extends string>({
 		const [command, args] = resolveRoomScript(roomName)
 		const child = await new Promise<ChildProcessWithoutNullStreams>(
 			(resolve) => {
-				const room = spawn(command, args, { env: process.env })
+				const room = spawn(command, args, {
+					env: { ...process.env, REALTIME_ROOM_KEY: roomKey },
+				})
 				const resolver = (data: Buffer) => {
 					const chunk = data.toString()
 					if (chunk === PROOF_OF_LIFE_SIGNAL) {
@@ -102,12 +102,6 @@ export function spawnRoom<RoomNames extends string>({
 			consumer: roomKey,
 			store,
 		})
-		const provideState = realtimeStateProvider({
-			socket: room,
-			consumer: roomKey,
-			store,
-		})
-		const unsubFromRoomKey = provideState(myRoomKeyAtom, roomKey)
 
 		const ownersOfRoomsAtoms = getInternalRelationsFromStore(
 			store,
@@ -123,7 +117,6 @@ export function spawnRoom<RoomNames extends string>({
 		)
 
 		room.on(`close`, () => {
-			unsubFromRoomKey()
 			unsubFromOwnerKeys()
 			unsubFromUsersInRooms()
 			destroyRoom({ store, socket, userKey })(roomKey)
@@ -150,11 +143,36 @@ export function provideEnterAndExit({
 			`📡`,
 			`socket`,
 			socket.id ?? `[ID MISSING?!]`,
-			`👤 ${userKey} enters room ${roomKey}`,
+			`👤 ${userKey} enters ${roomKey}`,
 		)
+		const childSocket = ROOMS.get(roomKey)
+		if (!childSocket) {
+			store.logger.error(`❌`, `unknown`, roomKey, `no room found with this id`)
+			return
+		}
+		const toUser = socket.emit.bind(socket)
+		childSocket.on(userKey, toUser)
+
+		const roomQueue: [string, ...Json.Array][] = []
+		const pushToRoomQueue = (payload: [string, ...Json.Array]): void => {
+			roomQueue.push(payload)
+		}
+		let toRoom = pushToRoomQueue
+		const forward: AllEventsListener<EventsMap> = (...payload) => {
+			toRoom([userKey, ...payload])
+		}
+		socket.onAny(forward)
 
 		const dcUserFromRoom = () => {
-			toRoom([`user-leaves`])
+			store.logger.info(
+				`📡`,
+				`socket`,
+				socket.id ?? `[ID MISSING?!]`,
+				`👤 ${userKey} is has lost connection to ${roomKey}`,
+			)
+			socket.offAny(forward)
+			childSocket.off(userKey, toUser)
+			toRoom([`user-leaves`, userKey])
 		}
 
 		const exitRoom = () => {
@@ -162,9 +180,8 @@ export function provideEnterAndExit({
 				`📡`,
 				`socket`,
 				socket.id ?? `[ID MISSING?!]`,
-				`👤 ${userKey} leaves room ${roomKey}`,
+				`👤 ${userKey} leaves ${roomKey}`,
 			)
-			socket.offAny(forward)
 			dcUserFromRoom()
 			editRelationsInStore(store, usersInRooms, (relations) => {
 				relations.delete({ room: roomKey, user: userKey })
@@ -174,27 +191,10 @@ export function provideEnterAndExit({
 			roomSocket.on(`joinRoom`, enterRoom)
 		}
 
-		const roomQueue: [string, ...Json.Array][] = []
-		const pushToRoomQueue = (payload: [string, ...Json.Array]): void => {
-			roomQueue.push(payload)
-		}
-		let toRoom = pushToRoomQueue
-		const forward: AllEventsListener<EventsMap> = (...payload) => {
-			toRoom([userKey, ...payload])
-		}
-		socket.onAny(forward)
-
 		editRelationsInStore(store, usersInRooms, (relations) => {
 			relations.set({ room: roomKey, user: userKey })
 		})
-		const childSocket = ROOMS.get(roomKey)
-		if (!childSocket) {
-			store.logger.error(`❌`, `unknown`, roomKey, `no room found with this id`)
-			return
-		}
-		childSocket.onAny((...payload) => {
-			socket.emit(...payload)
-		})
+
 		childSocket.emit(`user-joins`, userKey)
 
 		toRoom = (payload) => {
@@ -228,7 +228,7 @@ export function destroyRoom({
 			`📡`,
 			`socket`,
 			socket.id ?? `[ID MISSING?!]`,
-			`👤 ${userKey} attempts to delete room ${roomKey}`,
+			`👤 ${userKey} attempts to delete ${roomKey}`,
 		)
 		const owner = getFromStore(
 			store,
@@ -239,7 +239,7 @@ export function destroyRoom({
 				`📡`,
 				`socket`,
 				socket.id ?? `[ID MISSING?!]`,
-				`👤 ${userKey} deletes room ${roomKey}`,
+				`👤 ${userKey} deletes ${roomKey}`,
 			)
 			setIntoStore(store, roomKeysAtom, (s) => (s.delete(roomKey), s))
 			editRelationsInStore(store, usersInRooms, (relations) => {
@@ -256,7 +256,7 @@ export function destroyRoom({
 			`📡`,
 			`socket`,
 			socket.id ?? `[ID MISSING?!]`,
-			`👤 ${userKey} failed to delete room ${roomKey}; room owner is ${owner}`,
+			`👤 ${userKey} failed to delete ${roomKey}; its owner is ${owner}`,
 		)
 	}
 }