atom.io 0.46.4 → 0.46.6

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-react/use-realtime-rooms.ts

@@ -1,13 +1,61 @@
-import type { RoomSocketInterface } from "atom.io/realtime"
+import type { MutableAtomToken } from "atom.io"
+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 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 { usePullMutable } from "./use-pull-mutable-atom"
+import { usePullMutableAtomFamilyMember } from "./use-pull-mutable-family-member"
 
-export function useRealtimeRooms<RoomNames extends string>(): Socket<
-	{},
-	RoomSocketInterface<RoomNames>
-> {
+export type RealtimeRoomsTools = {
+	socket: 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 {
+	const store = React.useContext(StoreContext)
 	const { socket } = React.useContext(RealtimeContext)
-	return socket as Socket<{}, RoomSocketInterface<RoomNames>>
+	usePullMutable(roomKeysAtom)
+
+	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(
+		store,
+		ownersOfRooms,
+		`split`,
+	)
+	const myOwnedRoomsAtom = findInStore(store, ownedRoomsFamily, userKey)
+	usePullMutableAtomFamilyMember(ownedRoomsFamily, userKey)
+
+	return {
+		socket: socket as Socket<{}, RoomSocketInterface<RoomNames>>,
+		myRoomKey,
+		allRoomKeysAtom: roomKeysAtom,
+		myMutualsAtom,
+		myOwnedRoomsAtom,
+	}
 }

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/parent-socket.ts

@@ -66,10 +66,10 @@ export class ParentSocket<
 	protected incompleteData = ``
 	protected unprocessedEvents: string[] = []
 	protected relays: Map<string, SubjectSocket<any, any>>
-	protected relayServices: ((
+	protected initRelay: (
 		socket: SubjectSocket<any, any>,
 		userKey: UserKey,
-	) => (() => void) | void)[]
+	) => (() => void) | void
 	public proc: P
 
 	public id = `#####`
@@ -104,7 +104,9 @@ export class ParentSocket<
 		this.proc = proc
 		this.proc.stdin.resume()
 		this.relays = new Map()
-		this.relayServices = []
+		this.initRelay = () => {
+			this.logger.info(`🔗`, `nothing to relay`)
+		}
 
 		this.proc.stdin.on(
 			`data`,
@@ -174,19 +176,13 @@ export class ParentSocket<
 		}
 
 		this.on(`user-joins`, (userKey: UserKey) => {
-			this.logger.info(`👤`, `user`, userKey, `joined`)
+			this.logger.info(`👤`, userKey, `joined`)
 			const relay = new SubjectSocket(userKey)
 			this.relays.set(userKey, relay)
-			this.logger.info(
-				`🔗`,
-				`attaching services:`,
-				`[${[...this.relayServices.keys()].join(`, `)}]`,
-			)
-			for (const attachRelay of this.relayServices) {
-				const cleanupRelay = attachRelay(relay, userKey)
-				if (cleanupRelay) {
-					relay.disposalFunctions.push(cleanupRelay)
-				}
+			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)
@@ -215,6 +211,6 @@ export class ParentSocket<
 		) => (() => void) | void,
 	): void {
 		this.logger.info(`🔗`, `running relay method`)
-		this.relayServices.push(attachServices)
+		this.initRelay = attachServices
 	}
 }

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) {