atom.io 0.46.5 → 0.46.7

package/src/realtime/shared-room-store.ts

@@ -23,7 +23,7 @@ export type RoomSocketInterface<RoomNames extends string> = {
 }
 
 export const roomKeysAtom: MutableAtomToken<UList<RoomKey>> = mutableAtom({
-	key: `roomIndex`,
+	key: `roomKeys`,
 	class: UList,
 })
 
@@ -43,10 +43,10 @@ export const usersInRooms: JoinToken<`room`, RoomKey, `user`, UserKey, `1:n`> =
 	})
 
 export const visibleUsersInRoomsSelector: PureSelectorFamilyToken<
-	(RoomKey | UserKey)[],
+	[self: UserKey, ...RoomKey[]],
 	UserKey
 > = selectorFamily({
-	key: `selfList`,
+	key: `visibleUsersInRooms`,
 	get:
 		(userKey) =>
 		({ get }) => {
@@ -56,6 +56,41 @@ export const visibleUsersInRoomsSelector: PureSelectorFamilyToken<
 		},
 })
 
+export const visibilityFromRoomSelector: PureSelectorFamilyToken<
+	[self: RoomKey, ...UserKey[]],
+	RoomKey
+> = selectorFamily({
+	key: `visibilityFromRoom`,
+	get:
+		(roomKey) =>
+		({ get }) => {
+			const [usersOfRoomsAtoms] = getInternalRelations(usersInRooms, `split`)
+			const users = get(usersOfRoomsAtoms, roomKey)
+			return [roomKey, ...users]
+		},
+})
+
+export const mutualUsersSelector: ReadonlyPureSelectorFamilyToken<
+	UserKey[],
+	UserKey
+> = selectorFamily({
+	key: `mutualUsers`,
+	get:
+		(userKey) =>
+		({ get }) => {
+			const [usersOfRoomsAtoms, roomsOfUsersAtoms] = getInternalRelations(
+				usersInRooms,
+				`split`,
+			)
+			const rooms = get(roomsOfUsersAtoms, userKey)
+			for (const room of rooms) {
+				const users = get(usersOfRoomsAtoms, room)
+				return [...users]
+			}
+			return []
+		},
+})
+
 export const ownersOfRooms: JoinToken<`user`, UserKey, `room`, RoomKey, `1:n`> =
 	join({
 		key: `ownersOfRooms`,
@@ -64,17 +99,3 @@ export const ownersOfRooms: JoinToken<`user`, UserKey, `room`, RoomKey, `1:n`> =
 		isAType: isUserKey,
 		isBType: isRoomKey,
 	})
-
-export const usersInMyRoomView: ReadonlyPureSelectorFamilyToken<
-	MutableAtomToken<UList<RoomKey>>[],
-	UserKey
-> = selectorFamily({
-	key: `usersInMyRoomView`,
-	get:
-		(myUsername) =>
-		({ find }) => {
-			const [, roomsOfUsersAtoms] = getInternalRelations(usersInRooms, `split`)
-			const myRoomIndex = find(roomsOfUsersAtoms, myUsername)
-			return [myRoomIndex]
-		},
-})

package/src/realtime/socket-interface.ts

@@ -48,7 +48,7 @@ export type Socket = {
 	onAnyOutgoing: (
 		listener: (event: string, ...args: Json.Serializable[]) => void,
 	) => void
-	off: (event: string, listener: (...args: Json.Serializable[]) => void) => void
+	off: (event: string, listener?: (...args: Json.Serializable[]) => void) => void
 	offAny: (
 		listener: (event: string, ...args: Json.Serializable[]) => void,
 	) => void

package/src/realtime-client/continuity/register-and-attempt-confirmed-update.ts

@@ -7,6 +7,7 @@ import {
 	setEpochNumberOfContinuity,
 	setIntoStore,
 } from "atom.io/internal"
+import type { Json } from "atom.io/json"
 import type { Socket } from "atom.io/realtime"
 
 import {
@@ -27,7 +28,8 @@ export const useRegisterAndAttemptConfirmedUpdate =
 		>[],
 	) =>
 	(
-		confirmed: AtomIO.TransactionOutcomeEvent<AtomIO.TransactionToken<Fn>>,
+		confirmed: AtomIO.TransactionOutcomeEvent<AtomIO.TransactionToken<Fn>> &
+			Json.Serializable,
 	): void => {
 		function reconcileEpoch(
 			optimisticUpdate: AtomIO.TransactionOutcomeEvent<

package/src/realtime-client/continuity/use-conceal-state.ts

@@ -1,9 +1,10 @@
 import type { AtomToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import { disposeAtom } from "atom.io/internal"
+import type { Json } from "atom.io/json"
 
 export function useConcealState(store: Store) {
-	return (concealed: AtomToken<unknown>[]): void => {
+	return (concealed: AtomToken<Json.Serializable>[]): void => {
 		for (const token of concealed) {
 			disposeAtom(store, token)
 		}

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

@@ -1,7 +1,7 @@
 import type * as AtomIO from "atom.io"
 import { findInStore, setIntoStore, type Store } from "atom.io/internal"
 import type { Canonical, Json } from "atom.io/json"
-import type { Socket } from "socket.io-client"
+import type { Socket } from "atom.io/realtime"
 
 export function pullAtomFamilyMember<
 	J extends Json.Serializable,

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

@@ -1,7 +1,7 @@
 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 "socket.io-client"
+import type { Socket } from "atom.io/realtime"
 
 export function pullAtom<J extends Json.Serializable>(
 	store: Store,

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

@@ -7,7 +7,7 @@ import {
 	setIntoStore,
 } from "atom.io/internal"
 import type { Canonical } from "atom.io/json"
-import type { Socket } from "socket.io-client"
+import type { Socket } from "atom.io/realtime"
 
 export function pullMutableAtomFamilyMember<
 	T extends Transceiver<any, any, any>,

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

@@ -1,7 +1,7 @@
 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 "socket.io-client"
+import type { Socket } from "atom.io/realtime"
 
 export function pullMutableAtom<T extends Transceiver<any, any, any>>(
 	store: Store,

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

@@ -2,7 +2,7 @@ import type * as AtomIO from "atom.io"
 import type { Store } from "atom.io/internal"
 import { findInStore } from "atom.io/internal"
 import type { Canonical } from "atom.io/json"
-import type { Socket } from "socket.io-client"
+import type { Socket } from "atom.io/realtime"
 
 import { pullSelectorRoots } from "./pull-selector-roots"
 

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

@@ -2,7 +2,7 @@ import type { AtomToken, SelectorToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import { getFamilyOfToken, subscribeToState } from "atom.io/internal"
 import { parseJson } from "atom.io/json"
-import type { Socket } from "socket.io-client"
+import type { Socket } from "atom.io/realtime"
 
 import { pullAtom } from "./pull-atom"
 import { pullAtomFamilyMember } from "./pull-atom-family-member"

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

@@ -1,6 +1,6 @@
 import type * as AtomIO from "atom.io"
 import type { Store } from "atom.io/internal"
-import type { Socket } from "socket.io-client"
+import type { Socket } from "atom.io/realtime"
 
 import { pullSelectorRoots } from "./pull-selector-roots"
 

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

@@ -2,8 +2,8 @@ import type { WritableToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import { setIntoStore, subscribeToState } from "atom.io/internal"
 import type { Json } from "atom.io/json"
+import type { Socket } from "atom.io/realtime"
 import { employSocket, mutexAtoms } from "atom.io/realtime"
-import type { Socket } from "socket.io-client"
 
 export function pushState<J extends Json.Serializable>(
 	store: Store,

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

@@ -1,6 +1,5 @@
 import * as AtomIO from "atom.io"
-import type { SocketKey, UserKey } from "atom.io/realtime"
-import { storageSync } from "atom.io/web"
+import type { RoomKey, SocketKey, UserKey } from "atom.io/realtime"
 
 export const mySocketKeyAtom: AtomIO.RegularAtomToken<SocketKey | undefined> =
 	AtomIO.atom<SocketKey | undefined>({
@@ -12,5 +11,19 @@ export const myUserKeyAtom: AtomIO.RegularAtomToken<UserKey | null> =
 	AtomIO.atom<UserKey | null>({
 		key: `myUserKey`,
 		default: null,
-		effects: [storageSync(globalThis.localStorage, JSON, `myUserKey`)],
+		effects: [
+			(userKey) => {
+				if (typeof window !== `undefined`) {
+					void import(`atom.io/web`).then(({ storageSync }) => {
+						storageSync(globalThis.localStorage, JSON, `myUserKey`)(userKey)
+					})
+				}
+			},
+		],
+	})
+
+export const myRoomKeyAtom: AtomIO.RegularAtomToken<RoomKey | null> =
+	AtomIO.atom<RoomKey | null>({
+		key: `myRoomKey`,
+		default: null,
 	})

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

@@ -8,8 +8,7 @@ import {
 	subscribeToTransaction,
 } from "atom.io/internal"
 import type { Json } from "atom.io/json"
-import type { ContinuityToken } from "atom.io/realtime"
-import type { Socket } from "socket.io-client"
+import type { ContinuityToken, Socket } from "atom.io/realtime"
 
 import { useRegisterAndAttemptConfirmedUpdate } from "./continuity/register-and-attempt-confirmed-update"
 import { useConcealState } from "./continuity/use-conceal-state"

package/src/realtime-server/continuity/provide-outcomes.ts

@@ -82,7 +82,7 @@ export function provideOutcomes(
 
 					socket.emit(
 						`tx-new:${continuityKey}`,
-						redactedUpdate as Json.Serializable,
+						redactedUpdate as unknown as Json.Serializable,
 					)
 				} catch (thrown) {
 					if (thrown instanceof Error) {

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

@@ -58,18 +58,10 @@ export class ChildSocket<
 	) {
 		super((event, ...args) => {
 			const stringifiedEvent = JSON.stringify([event, ...args]) + `\x03`
-			const errorHandler = (err: { code: string }) => {
-				if (err.code === `EPIPE`) {
-					console.error(`EPIPE error during write`, this.proc.stdin)
-				}
-				this.proc.stdin.removeListener(`error`, errorHandler)
-			}
-
-			this.proc.stdin.once(`error`, errorHandler)
 			this.proc.stdin.write(stringifiedEvent)
-
 			return this
 		})
+
 		this.proc = proc
 		this.key = key
 		this.logger = logger ?? {
@@ -208,6 +200,11 @@ export class ChildSocket<
 				++idx
 			}
 		})
+		this.proc.stdin.once(`error`, (err: { code: string }) => {
+			if (err.code === `EPIPE`) {
+				console.error(`EPIPE error during write`, this.proc.stdin)
+			}
+		})
 		if (proc.pid) {
 			this.id = proc.pid.toString()
 		}

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

@@ -179,18 +179,11 @@ export class ParentSocket<
 			this.logger.info(`👤`, userKey, `joined`)
 			const relay = new SubjectSocket(userKey)
 			this.relays.set(userKey, relay)
-			this.logger.info(
-				`🔗`,
-				`attaching services for user`,
-				userKey,
-				// `[${[...this.initRelay.keys()].join(`, `)}]`,
-			)
-			// for (const attachRelay of this.initRelay) {
+			this.logger.info(`🔗`, `attaching services for user`, userKey)
 			const cleanupRelay = this.initRelay(relay, userKey)
 			if (cleanupRelay) {
 				relay.disposalFunctions.push(cleanupRelay)
 			}
-			// }
 			this.on(userKey, (...data) => {
 				relay.in.next(data)
 			})

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

@@ -29,13 +29,15 @@ import {
 	ownersOfRooms,
 	roomKeysAtom,
 	usersInRooms,
+	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 type { ServerConfig } from "./server-config"
+import { realtimeStateProvider } from "./realtime-state-provider"
 
 export type RoomMap = Map<
 	string,
@@ -87,19 +89,47 @@ export function spawnRoom<RoomNames extends string>({
 				room.stdout.on(`data`, resolver)
 			},
 		)
-		const roomSocket = new ChildSocket(child, roomKey)
-		ROOMS.set(roomKey, roomSocket)
-		setIntoStore(store, roomKeysAtom, (index) => (index.add(roomKey), index))
 
+		const room = new ChildSocket(child, roomKey)
+		ROOMS.set(roomKey, room)
+		setIntoStore(store, roomKeysAtom, (index) => (index.add(roomKey), index))
 		editRelationsInStore(store, ownersOfRooms, (relations) => {
 			relations.set({ room: roomKey, user: userKey })
 		})
 
-		roomSocket.on(`close`, () => {
+		const provideMutableFamily = realtimeMutableFamilyProvider({
+			socket: room,
+			consumer: roomKey,
+			store,
+		})
+		const provideState = realtimeStateProvider({
+			socket: room,
+			consumer: roomKey,
+			store,
+		})
+		const unsubFromRoomKey = provideState(myRoomKeyAtom, roomKey)
+
+		const ownersOfRoomsAtoms = getInternalRelationsFromStore(
+			store,
+			ownersOfRooms,
+		)
+		const unsubFromOwnerKeys = provideMutableFamily(ownersOfRoomsAtoms, [
+			roomKey,
+		])
+		const usersInRoomsAtoms = getInternalRelationsFromStore(store, usersInRooms)
+		const unsubFromUsersInRooms = provideMutableFamily(
+			usersInRoomsAtoms,
+			findInStore(store, visibilityFromRoomSelector, roomKey),
+		)
+
+		room.on(`close`, () => {
+			unsubFromRoomKey()
+			unsubFromOwnerKeys()
+			unsubFromUsersInRooms()
 			destroyRoom({ store, socket, userKey })(roomKey)
 		})
 
-		return roomSocket
+		return room
 	}
 }
 
@@ -115,7 +145,7 @@ export function provideEnterAndExit({
 	roomSocket,
 	userKey,
 }: ProvideEnterAndExitConfig): (roomKey: RoomKey) => void {
-	const enterRoom = (roomKey: RoomKey) => {
+	const enterRoom = (roomKey: RoomKey): void => {
 		store.logger.info(
 			`📡`,
 			`socket`,
@@ -123,6 +153,10 @@ export function provideEnterAndExit({
 			`👤 ${userKey} enters room ${roomKey}`,
 		)
 
+		const dcUserFromRoom = () => {
+			toRoom([`user-leaves`])
+		}
+
 		const exitRoom = () => {
 			store.logger.info(
 				`📡`,
@@ -131,17 +165,15 @@ export function provideEnterAndExit({
 				`👤 ${userKey} leaves room ${roomKey}`,
 			)
 			socket.offAny(forward)
-			toRoom([`user-leaves`])
+			dcUserFromRoom()
 			editRelationsInStore(store, usersInRooms, (relations) => {
 				relations.delete({ room: roomKey, user: userKey })
 			})
+
 			roomSocket.off(`leaveRoom`, exitRoom)
 			roomSocket.on(`joinRoom`, enterRoom)
 		}
 
-		roomSocket.on(`leaveRoom`, exitRoom)
-		roomSocket.off(`joinRoom`, enterRoom)
-
 		const roomQueue: [string, ...Json.Array][] = []
 		const pushToRoomQueue = (payload: [string, ...Json.Array]): void => {
 			roomQueue.push(payload)
@@ -158,7 +190,7 @@ export function provideEnterAndExit({
 		const childSocket = ROOMS.get(roomKey)
 		if (!childSocket) {
 			store.logger.error(`❌`, `unknown`, roomKey, `no room found with this id`)
-			return null
+			return
 		}
 		childSocket.onAny((...payload) => {
 			socket.emit(...payload)
@@ -172,6 +204,10 @@ export function provideEnterAndExit({
 			const payload = roomQueue.shift()
 			if (payload) toRoom(payload)
 		}
+
+		socket.on(`disconnect`, dcUserFromRoom)
+		roomSocket.on(`leaveRoom`, exitRoom)
+		roomSocket.off(`joinRoom`, enterRoom)
 	}
 	roomSocket.on(`joinRoom`, enterRoom)
 	return enterRoom
@@ -229,6 +265,9 @@ export type ProvideRoomsConfig<RoomNames extends string> = {
 	resolveRoomScript: (path: RoomNames) => [string, string[]]
 	roomNames: RoomNames[]
 	roomTimeLimit?: number
+	userKey: UserKey
+	store: RootStore
+	socket: Socket
 }
 export function provideRooms<RoomNames extends string>({
 	store = IMPLICIT.STORE,
@@ -236,11 +275,15 @@ export function provideRooms<RoomNames extends string>({
 	resolveRoomScript,
 	roomNames,
 	userKey,
-}: ProvideRoomsConfig<RoomNames> & ServerConfig): () => void {
+}: ProvideRoomsConfig<RoomNames>): () => void {
 	const roomSocket = castSocket<
 		TypedSocket<RoomSocketInterface<RoomNames>, never>
 	>(socket, createRoomSocketGuard(roomNames))
-	const exposeMutable = realtimeMutableProvider({ socket, store, userKey })
+	const exposeMutable = realtimeMutableProvider({
+		socket,
+		store,
+		consumer: userKey,
+	})
 	const unsubFromRoomKeys = exposeMutable(roomKeysAtom)
 	const usersInRoomsAtoms = getInternalRelationsFromStore(store, usersInRooms)
 	const [, usersInRoomsAtomsUsersOnly] = getInternalRelationsFromStore(
@@ -257,7 +300,7 @@ export function provideRooms<RoomNames extends string>({
 	const exposeMutableFamily = realtimeMutableFamilyProvider({
 		socket,
 		store,
-		userKey,
+		consumer: userKey,
 	})
 	const unsubFromUsersInRooms = exposeMutableFamily(
 		usersInRoomsAtoms,
@@ -267,7 +310,12 @@ export function provideRooms<RoomNames extends string>({
 		ownersOfRoomsAtoms,
 		usersWhoseRoomsCanBeSeenSelector,
 	)
-	const enterRoom = provideEnterAndExit({ store, socket, roomSocket, userKey })
+	const enterRoom = provideEnterAndExit({
+		store,
+		socket,
+		roomSocket,
+		userKey,
+	})
 
 	const userRoomSet = getFromStore(store, usersInRoomsAtomsUsersOnly, userKey)
 	for (const userRoomKey of userRoomSet) {

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

@@ -14,7 +14,7 @@ import type { ServerConfig } from "."
 export type FamilyProvider = ReturnType<typeof realtimeAtomFamilyProvider>
 export function realtimeAtomFamilyProvider({
 	socket,
-	userKey,
+	consumer,
 	store = IMPLICIT.STORE,
 }: ServerConfig) {
 	return function familyProvider<
@@ -22,8 +22,17 @@ export function realtimeAtomFamilyProvider({
 		K extends Canonical,
 	>(
 		family: AtomIO.RegularAtomFamilyToken<J, K>,
-		index: AtomIO.ReadableToken<Iterable<NoInfer<K>>>,
+		index: AtomIO.ReadableToken<Iterable<NoInfer<K>>> | Iterable<NoInfer<K>>,
 	): () => void {
+		const [dynamicIndex, staticIndex]:
+			| [AtomIO.ReadableToken<Iterable<NoInfer<K>>>, undefined]
+			| [undefined, Iterable<NoInfer<K>>] = (() => {
+			if (typeof index === `object` && `key` in index && `type` in index) {
+				return [index, undefined] as const
+			}
+			return [undefined, index] as const
+		})()
+
 		const coreSubscriptions = new Set<() => void>()
 		const clearCoreSubscriptions = () => {
 			for (const unsub of coreSubscriptions) unsub()
@@ -70,7 +79,7 @@ export function realtimeAtomFamilyProvider({
 					store.logger.info(
 						`🙈`,
 						`user`,
-						userKey,
+						consumer,
 						`unsubscribed from state "${token.key}"`,
 					)
 					fillUnsubRequest(token.key)
@@ -91,18 +100,23 @@ export function realtimeAtomFamilyProvider({
 			store.logger.info(
 				`👀`,
 				`user`,
-				userKey,
+				consumer,
 				`can subscribe to family "${family.key}"`,
 			)
 			coreSubscriptions.add(
 				employSocket(socket, `sub:${family.key}`, (subKey: K) => {
-					const exposedSubKeys = getFromStore(store, index)
+					let exposedSubKeys: Iterable<K>
+					if (dynamicIndex) {
+						exposedSubKeys = getFromStore(store, dynamicIndex)
+					} else {
+						exposedSubKeys = staticIndex
+					}
 					const shouldExpose = isAvailable(exposedSubKeys, subKey)
 					if (shouldExpose) {
 						store.logger.info(
 							`👀`,
 							`user`,
-							userKey,
+							consumer,
 							`is approved for a subscription to`,
 							subKey,
 							`in family "${family.key}"`,
@@ -112,7 +126,7 @@ export function realtimeAtomFamilyProvider({
 						store.logger.info(
 							`❌`,
 							`user`,
-							userKey,
+							consumer,
 							`is denied for a subscription to`,
 							subKey,
 							`in family "${family.key}"`,
@@ -122,35 +136,37 @@ export function realtimeAtomFamilyProvider({
 					}
 				}),
 			)
-			coreSubscriptions.add(
-				subscribeToState(
-					store,
-					index,
-					`expose-family:${family.key}:${socket.id}`,
-					({ newValue: newExposedSubKeys }) => {
-						store.logger.info(
-							`👀`,
-							`user`,
-							userKey,
-							`has the following keys available for family "${family.key}"`,
-							newExposedSubKeys,
-						)
-						for (const subKey of newExposedSubKeys) {
-							if (familyMemberSubscriptionsWanted.has(stringifyJson(subKey))) {
-								store.logger.info(
-									`👀`,
-									`user`,
-									userKey,
-									`is retroactively approved for a subscription to`,
-									subKey,
-									`in family "${family.key}"`,
-								)
-								exposeFamilyMembers(subKey)
+			if (dynamicIndex) {
+				coreSubscriptions.add(
+					subscribeToState(
+						store,
+						dynamicIndex,
+						`expose-family:${family.key}:${socket.id}`,
+						({ newValue: newExposedSubKeys }) => {
+							store.logger.info(
+								`👀`,
+								`user`,
+								consumer,
+								`has the following keys available for family "${family.key}"`,
+								newExposedSubKeys,
+							)
+							for (const subKey of newExposedSubKeys) {
+								if (familyMemberSubscriptionsWanted.has(stringifyJson(subKey))) {
+									store.logger.info(
+										`👀`,
+										`user`,
+										consumer,
+										`is retroactively approved for a subscription to`,
+										subKey,
+										`in family "${family.key}"`,
+									)
+									exposeFamilyMembers(subKey)
+								}
 							}
-						}
-					},
-				),
-			)
+						},
+					),
+				)
+			}
 		}
 
 		start()