atom.io 0.40.6 → 0.40.7

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

@@ -1,48 +1,89 @@
 import type { ChildProcessWithoutNullStreams } from "node:child_process"
 import { spawn } from "node:child_process"
 
-import type {
-	Loadable,
-	ReadonlyPureSelectorFamilyToken,
-	RegularAtomFamilyToken,
-} from "atom.io"
-import { atomFamily, selectorFamily } from "atom.io"
+import type { TransactionIO, TransactionToken } from "atom.io"
+import { transaction } from "atom.io"
+import { editRelationsInStore } from "atom.io/internal"
+import type { UserInRoomMeta } from "atom.io/realtime/shared-room-store"
+import { roomIndex, usersInRooms } from "atom.io/realtime/shared-room-store"
 
 import { ChildSocket } from "../ipc-sockets"
+import type { RoomKey } from "./server-user-store"
 
-export type RoomArguments =
-	| [script: string, options: string[]]
-	| [script: string]
+export const ROOMS: Map<
+	string,
+	ChildSocket<any, any, ChildProcessWithoutNullStreams>
+> = new Map()
 
-export const roomArgumentsAtoms: RegularAtomFamilyToken<RoomArguments, string> =
-	atomFamily<RoomArguments, string>({
-		key: `roomArguments`,
-		default: [`echo`, [`Hello World!`]],
+export async function spawnRoom(
+	roomId: string,
+	script: string,
+	options: string[],
+): Promise<ChildSocket<any, any>> {
+	const child = await new Promise<ChildProcessWithoutNullStreams>((resolve) => {
+		const room = spawn(script, options, { env: process.env })
+		const resolver = (data: Buffer) => {
+			if (data.toString() === `ALIVE`) {
+				room.stdout.off(`data`, resolver)
+				resolve(room)
+			}
+		}
+		room.stdout.on(`data`, resolver)
 	})
+	ROOMS.set(roomId, new ChildSocket(child, roomId))
+	return new ChildSocket(child, roomId)
+}
 
-export const roomSelectors: ReadonlyPureSelectorFamilyToken<
-	Loadable<ChildSocket<any, any>>,
-	string
-> = selectorFamily<Loadable<ChildSocket<any, any>>, string>({
-	key: `room`,
-	get:
-		(roomId) =>
-		async ({ get, find }) => {
-			const argumentsState = find(roomArgumentsAtoms, roomId)
-			const args = get(argumentsState)
-			const [script, options] = args
-			const child = await new Promise<ChildProcessWithoutNullStreams>(
-				(resolve) => {
-					const room = spawn(script, options, { env: process.env })
-					const resolver = (data: Buffer) => {
-						if (data.toString() === `ALIVE`) {
-							room.stdout.off(`data`, resolver)
-							resolve(room)
-						}
-					}
-					room.stdout.on(`data`, resolver)
+export const joinRoomTX: TransactionToken<
+	(roomId: string, userId: string, enteredAtEpoch: number) => UserInRoomMeta
+> = transaction({
+	key: `joinRoom`,
+	do: (tools, roomId, userId, enteredAtEpoch) => {
+		const meta = { enteredAtEpoch }
+		editRelationsInStore(
+			usersInRooms,
+			(relations) => {
+				relations.set({ room: roomId, user: userId }, meta)
+			},
+			tools.env().store,
+		)
+		return meta
+	},
+})
+export type JoinRoomIO = TransactionIO<typeof joinRoomTX>
+
+export const leaveRoomTX: TransactionToken<
+	(roomId: string, userId: string) => void
+> = transaction({
+	key: `leaveRoom`,
+	do: ({ env }, roomId, userId) => {
+		editRelationsInStore(
+			usersInRooms,
+			(relations) => {
+				relations.delete({ room: roomId, user: userId })
+			},
+			env().store,
+		)
+	},
+})
+export type LeaveRoomIO = TransactionIO<typeof leaveRoomTX>
+
+export const destroyRoomTX: TransactionToken<(roomKey: RoomKey) => void> =
+	transaction({
+		key: `destroyRoom`,
+		do: ({ set, env }, roomId) => {
+			editRelationsInStore(
+				usersInRooms,
+				(relations) => {
+					relations.delete({ room: roomId })
 				},
+				env().store,
 			)
-			return new ChildSocket(child, roomId)
+			set(roomIndex, (s) => (s.delete(roomId), s))
+			const room = ROOMS.get(roomId)
+			if (room) {
+				room.emit(`exit`)
+				ROOMS.delete(roomId)
+			}
 		},
-})
+	})

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

@@ -2,9 +2,10 @@ import type {
 	Hierarchy,
 	JoinToken,
 	MutableAtomToken,
+	PureSelectorFamilyToken,
 	RegularAtomFamilyToken,
 } from "atom.io"
-import { atomFamily, join, mutableAtom } from "atom.io"
+import { atomFamily, join, mutableAtom, selectorFamily } from "atom.io"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 
 import type { Socket } from ".."
@@ -53,3 +54,13 @@ export const usersOfSockets: JoinToken<
 	isAType: (s): s is UserKey => s.startsWith(`user::`),
 	isBType: (s): s is SocketKey => s.startsWith(`socket::`),
 })
+
+export const userMutualSituationalAwarenessIndexes: PureSelectorFamilyToken<
+	UserKey[],
+	UserKey
+> = selectorFamily<UserKey[], UserKey>({
+	key: `userMutualSituationalAwarenessIndexes`,
+	get: (userId) => () => {
+		return [userId]
+	},
+})

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

@@ -3,6 +3,7 @@ import { getFromStore, IMPLICIT, subscribeToState } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 
 import type { ServerConfig } from "."
+import { employSocket } from "./employ-socket"
 
 export type StateProvider = ReturnType<typeof realtimeStateProvider>
 export function realtimeStateProvider({
@@ -12,39 +13,39 @@ export function realtimeStateProvider({
 	return function stateProvider<J extends Json.Serializable>(
 		token: AtomIO.WritableToken<J>,
 	): () => void {
-		let unsubscribeFromStateUpdates: (() => void) | undefined
-
-		const fillSubRequest = () => {
-			socket.emit(`serve:${token.key}`, getFromStore(store, token))
+		const subscriptions = new Set<() => void>()
+		const clearSubscriptions = () => {
+			for (const unsub of subscriptions) unsub()
+			subscriptions.clear()
+		}
 
-			unsubscribeFromStateUpdates = subscribeToState(
-				store,
-				token,
-				`expose-single:${socket.id}`,
-				({ newValue }) => {
-					socket.emit(`serve:${token.key}`, newValue)
-				},
+		const start = () => {
+			subscriptions.add(
+				employSocket(socket, `sub:${token.key}`, () => {
+					clearSubscriptions()
+					socket.emit(`serve:${token.key}`, getFromStore(store, token))
+					subscriptions.add(
+						subscribeToState(
+							store,
+							token,
+							`expose-single:${socket.id}`,
+							({ newValue }) => {
+								socket.emit(`serve:${token.key}`, newValue)
+							},
+						),
+					)
+					subscriptions.add(
+						employSocket(socket, `unsub:${token.key}`, () => {
+							clearSubscriptions()
+							start()
+						}),
+					)
+				}),
 			)
-
-			const fillUnsubRequest = () => {
-				socket.off(`unsub:${token.key}`, fillUnsubRequest)
-				if (unsubscribeFromStateUpdates) {
-					unsubscribeFromStateUpdates()
-					unsubscribeFromStateUpdates = undefined
-				}
-			}
-
-			socket.on(`unsub:${token.key}`, fillUnsubRequest)
 		}
 
-		socket.on(`sub:${token.key}`, fillSubRequest)
+		start()
 
-		return () => {
-			socket.off(`sub:${token.key}`, fillSubRequest)
-			if (unsubscribeFromStateUpdates) {
-				unsubscribeFromStateUpdates()
-				unsubscribeFromStateUpdates = undefined
-			}
-		}
+		return clearSubscriptions
 	}
 }

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

@@ -1,35 +1,81 @@
 import type { WritableToken } from "atom.io"
-import { IMPLICIT, setIntoStore } from "atom.io/internal"
+import {
+	findInStore,
+	getFromStore,
+	IMPLICIT,
+	setIntoStore,
+	subscribeToState,
+} from "atom.io/internal"
+import {
+	operateOnStore,
+	OWN_OP,
+} from "atom.io/internal/set-state/operate-on-store"
 import type { Json } from "atom.io/json"
+import { mutexAtoms } from "atom.io/realtime/mutex-store"
 
 import type { ServerConfig } from "."
+import { employSocket } from "./employ-socket"
 
 export type StateReceiver = ReturnType<typeof realtimeStateReceiver>
 export function realtimeStateReceiver({
 	socket,
 	store = IMPLICIT.STORE,
 }: ServerConfig) {
-	return function stateReceiver<J extends Json.Serializable>(
-		token: WritableToken<J>,
+	return function stateReceiver<S extends Json.Serializable, C extends S>(
+		clientToken: WritableToken<C>,
+		serverToken: WritableToken<S> = clientToken,
 	): () => void {
-		const publish = (newValue: J) => {
-			setIntoStore(store, token, newValue)
+		const mutexAtom = findInStore(store, mutexAtoms, serverToken.key)
+
+		const subscriptions = new Set<() => void>()
+		const clearSubscriptions = () => {
+			for (const unsub of subscriptions) unsub()
+			subscriptions.clear()
 		}
 
-		const fillPubUnclaim = () => {
-			socket.off(`pub:${token.key}`, publish)
-			socket.off(`unclaim:${token.key}`, fillPubUnclaim)
+		const permitPublish = () => {
+			clearSubscriptions()
+			subscriptions.add(
+				employSocket(socket, `pub:${clientToken.key}`, (newValue) => {
+					setIntoStore(store, serverToken, newValue as C)
+				}),
+			)
+			subscriptions.add(
+				employSocket(socket, `unclaim:${clientToken.key}`, () => {
+					setIntoStore(store, mutexAtom, false)
+					clearSubscriptions()
+					start()
+				}),
+			)
 		}
-		const fillPubClaim = () => {
-			socket.on(`pub:${token.key}`, publish)
-			socket.on(`unclaim:${token.key}`, fillPubUnclaim)
+
+		const start = () => {
+			subscriptions.add(
+				employSocket(socket, `claim:${clientToken.key}`, () => {
+					if (getFromStore(store, mutexAtom)) {
+						clearSubscriptions()
+						subscriptions.add(
+							subscribeToState(store, mutexAtom, socket.id!, () => {
+								const currentValue = getFromStore(store, mutexAtom)
+								if (currentValue === false) {
+									operateOnStore(OWN_OP, store, mutexAtom, true)
+									permitPublish()
+									socket.emit(`claim-result:${clientToken.key}`, true)
+								}
+							}),
+						)
+						socket.emit(`claim-result:${clientToken.key}`, false)
+						return
+					}
+					setIntoStore(store, mutexAtom, true)
+					permitPublish()
+					socket.emit(`claim-result:${clientToken.key}`, true)
+				}),
+			)
 		}
 
-		socket.on(`claim:${token.key}`, fillPubClaim)
+		start()
 
-		return () => {
-			socket.off(`claim:${token.key}`, fillPubClaim)
-			socket.off(`pub:${token.key}`, publish)
-		}
+		return clearSubscriptions
 	}
 }

package/src/realtime-server/server-config.ts

@@ -0,0 +1,9 @@
+import type { RootStore } from "atom.io/internal"
+
+import type { Socket } from "./socket-interface"
+
+export type ServerConfig = {
+	socket: Socket
+	store?: RootStore
+	mutex?: Set<string>
+}

package/src/realtime-server/socket-interface.ts

@@ -0,0 +1,14 @@
+import type { Json } from "atom.io/json"
+
+export type Socket = {
+	id: string | undefined
+	on: (event: string, listener: (...args: Json.Serializable[]) => void) => void
+	onAny: (
+		listener: (event: string, ...args: Json.Serializable[]) => void,
+	) => void
+	off: (event: string, listener: (...args: Json.Serializable[]) => void) => void
+	offAny: (
+		listener: (event: string, ...args: Json.Serializable[]) => void,
+	) => void
+	emit: (event: string, ...args: Json.Serializable[]) => void
+}

package/src/realtime-testing/setup-realtime-test.tsx

@@ -1,3 +1,4 @@
+import { ChildProcess } from "node:child_process"
 import * as http from "node:http"
 
 import type { RenderResult } from "@testing-library/react"
@@ -15,10 +16,10 @@ import {
 } from "atom.io/internal"
 import { toEntries } from "atom.io/json"
 import * as AR from "atom.io/react"
-import * as RT from "atom.io/realtime"
 import * as RTC from "atom.io/realtime-client"
 import * as RTR from "atom.io/realtime-react"
 import * as RTS from "atom.io/realtime-server"
+import { SetRTX } from "atom.io/transceivers/set-rtx"
 import * as Happy from "happy-dom"
 import * as React from "react"
 import * as SocketIO from "socket.io"
@@ -30,27 +31,49 @@ let testNumber = 0
 /* eslint-disable no-console */
 
 function prefixLogger(store: Store, prefix: string) {
-	store.loggers[0] = new AtomIO.AtomIOLogger(`info`, undefined, {
-		info: (...args) => {
-			console.info(prefix, ...args)
-		},
-		warn: (...args) => {
-			console.warn(prefix, ...args)
+	store.loggers[0] = new AtomIO.AtomIOLogger(
+		`info`,
+		(...params) => {
+			let idx = 0
+			for (const param of params) {
+				if (param instanceof SocketIO.Socket) {
+					params[idx] = `Socket:${param.id}`
+				}
+				if (param instanceof RTS.ChildSocket) {
+					params[idx] = `ChildSocket:${param.id}`
+				}
+				if (param instanceof ChildProcess) {
+					params[idx] = `ChildProcess:${param.pid}`
+				}
+				if (param instanceof SetRTX) {
+					params[idx] =
+						`SetRTX(${param.size}) {${[...param].join(`, `)}} at ${param.cacheIdx}`
+				}
+				idx++
+			}
+			return params
 		},
-		error: (...args) => {
-			console.error(prefix, ...args)
+		{
+			info: (...params) => {
+				console.info(prefix, ...params)
+			},
+			warn: (...params) => {
+				console.warn(prefix, ...params)
+			},
+			error: (...params) => {
+				console.error(prefix, ...params)
+			},
 		},
-	})
+	)
 }
 
 export type TestSetupOptions = {
-	port: number
 	immortal?: { server?: boolean }
 	server: (tools: {
 		socket: SocketIO.Socket
 		silo: AtomIO.Silo
 		enableLogging: () => void
-	}) => void
+	}) => (() => void) | void
 }
 export type TestSetupOptions__SingleClient = TestSetupOptions & {
 	client: React.FC
@@ -105,10 +128,11 @@ export const setupRealtimeTestServer = (
 		},
 		IMPLICIT.STORE,
 	)
+	// prefixLogger(silo.store, `server`)
 	const socketRealm = new AtomIO.Realm<RTS.SocketSystemHierarchy>(silo.store)
 
 	const httpServer = http.createServer((_, res) => res.end(`Hello World!`))
-	const address = httpServer.listen(options.port).address()
+	const address = httpServer.listen().address()
 	const port =
 		typeof address === `string` ? null : address === null ? null : address.port
 	if (port === null) throw new Error(`Could not determine port for test server`)
@@ -138,6 +162,8 @@ export const setupRealtimeTestServer = (
 		}
 	})
 
+	const serviceDisposalFunctions: Array<() => void> = []
+
 	server.on(`connection`, (socket: SocketIO.Socket) => {
 		let userKey: string | null = null
 		function enableLogging() {
@@ -158,19 +184,26 @@ export const setupRealtimeTestServer = (
 				console.log(`${userKey} disconnected`)
 			})
 		}
-		options.server({ socket, enableLogging, silo })
+		const disposeServices = options.server({ socket, enableLogging, silo })
+		if (disposeServices) {
+			serviceDisposalFunctions.push(disposeServices)
+		}
 	})
 
 	const dispose = async () => {
-		await server.close()
-		const roomKeys = getFromStore(silo.store, RT.roomIndex)
-		for (const roomKey of roomKeys) {
-			const roomState = findInStore(silo.store, RTS.roomSelectors, roomKey)
-			const room = getFromStore(silo.store, roomState)
-			if (room && !(room instanceof Promise)) {
-				room.process.kill()
-			}
+		for (const disposeSocketServices of serviceDisposalFunctions) {
+			disposeSocketServices()
 		}
+		await server.close()
+
+		// const roomKeys = getFromStore(silo.store, RT.roomIndex)
+		// for (const roomKey of roomKeys) {
+		// 	const roomState = findInStore(silo.store, RTS.roomSelectors, roomKey)
+		// 	const room = getFromStore(silo.store, roomState)
+		// 	if (room && !(room instanceof Promise)) {
+		// 		room.process.kill()
+		// 	}
+		// } // ❗ POSSIBLY STILL NEEDED
 		silo.store.valueMap.clear()
 	}
 
@@ -212,7 +245,7 @@ export const setupRealtimeTestClient = (
 		}
 
 		const enableLogging = () => {
-			prefixLogger(silo.store, name)
+			// prefixLogger(silo.store, name)
 			socket.onAny((event, ...args) => {
 				console.log(`📡 `, name, event, ...args)
 			})

package/src/web/index.ts

@@ -1 +1 @@
-export * from "./persist-sync"
+export * from "./storage-sync"

package/src/web/{persist-sync.ts → storage-sync.ts}

@@ -5,13 +5,16 @@ export type StringInterface<T> = {
 	parse: (s: string) => T
 }
 
-export const persistSync =
+export const storageSync =
 	<T>(
-		storage: Storage,
+		storage: Storage | undefined,
 		{ stringify, parse }: StringInterface<T>,
 		key: string,
 	): AtomEffect<T> =>
 	({ setSelf, onSet }) => {
+		if (!storage) {
+			return
+		}
 		const savedValue = storage.getItem(key)
 		if (savedValue != null) setSelf(parse(savedValue))
 

package/src/internal/store/mint-or-counterfeit.ts

@@ -1,108 +0,0 @@
-import type {
-	AtomFamilyToken,
-	AtomToken,
-	MutableAtomFamilyToken,
-	MutableAtomToken,
-	ReadableFamilyToken,
-	ReadableToken,
-	ReadonlyPureSelectorFamilyToken,
-	ReadonlyPureSelectorToken,
-	RegularAtomFamilyToken,
-	RegularAtomToken,
-	SelectorFamilyToken,
-	SelectorToken,
-	WritableFamilyToken,
-	WritablePureSelectorFamilyToken,
-	WritablePureSelectorToken,
-	WritableToken,
-} from "atom.io"
-import type { Canonical } from "atom.io/json"
-import { stringifyJson } from "atom.io/json"
-
-import type { Transceiver } from "../mutable"
-
-export const COUNTERFEIT: unique symbol = Symbol(`counterfeit`)
-
-export const FAMILY_MEMBER_TOKEN_TYPES = {
-	atom_family: `atom`,
-	molecule_family: `molecule`,
-	mutable_atom_family: `mutable_atom`,
-	readonly_held_selector_family: `readonly_held_selector`,
-	readonly_pure_selector_family: `readonly_pure_selector`,
-	writable_held_selector_family: `writable_held_selector`,
-	writable_pure_selector_family: `writable_pure_selector`,
-} as const
-
-export function mint<
-	T extends Transceiver<any, any, any>,
-	K extends Canonical,
-	Key extends K,
->(token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T>
-
-export function mint<T, K extends Canonical, Key extends K, E>(
-	token: RegularAtomFamilyToken<T, K, E>,
-	key: Key,
-	counterfeit?: typeof COUNTERFEIT,
-): RegularAtomToken<T, Key, E>
-
-export function mint<T, K extends Canonical, Key extends K, E>(
-	token: AtomFamilyToken<T, K, E>,
-	key: Key,
-	counterfeit?: typeof COUNTERFEIT,
-): AtomToken<T, Key, E>
-
-export function mint<T, K extends Canonical, Key extends K, E>(
-	token: WritablePureSelectorFamilyToken<T, K, E>,
-	key: Key,
-	counterfeit?: typeof COUNTERFEIT,
-): WritablePureSelectorToken<T, Key, E>
-
-export function mint<T, K extends Canonical, Key extends K, E>(
-	token: ReadonlyPureSelectorFamilyToken<T, K, E>,
-	key: Key,
-	counterfeit?: typeof COUNTERFEIT,
-): ReadonlyPureSelectorToken<T, Key, E>
-
-export function mint<T, K extends Canonical, Key extends K, E>(
-	token: SelectorFamilyToken<T, K, E>,
-	key: Key,
-	counterfeit?: typeof COUNTERFEIT,
-): SelectorToken<T, Key, E>
-
-export function mint<T, K extends Canonical, Key extends K, E>(
-	token: WritableFamilyToken<T, K, E>,
-	key: Key,
-	counterfeit?: typeof COUNTERFEIT,
-): WritableToken<T, Key, E>
-
-export function mint<T, K extends Canonical, Key extends K, E>(
-	token: ReadableFamilyToken<T, K, E>,
-	key: Key,
-	counterfeit?: typeof COUNTERFEIT,
-): ReadableToken<T, Key, E>
-
-export function mint(
-	token: ReadableFamilyToken<any, any, any>,
-	key: Canonical,
-	counterfeit?: typeof COUNTERFEIT,
-): ReadableToken<any, any, any> {
-	const subKey = stringifyJson(key)
-	const fullKey = `${token.key}(${subKey})`
-	const type = FAMILY_MEMBER_TOKEN_TYPES[token.type]
-	const stateToken: ReadableToken<any> & {
-		counterfeit?: boolean
-	} = {
-		key: fullKey,
-		type,
-		family: {
-			key: token.key,
-			subKey,
-		},
-	}
-
-	if (counterfeit) {
-		stateToken.counterfeit = true
-	}
-
-	return stateToken
-}

package/src/realtime-react/on-mount.ts

@@ -1,5 +0,0 @@
-import { useSingleEffect } from "./use-single-effect"
-
-export function onMount(effect: () => (() => void) | undefined | void): void {
-	useSingleEffect(effect, [])
-}