atom.io 0.44.12 → 0.44.13

package/src/realtime/cast-socket.ts

@@ -0,0 +1,73 @@
+import type { Loadable } from "atom.io"
+import type { Json } from "atom.io/json"
+
+import type { EventsMap, Socket, TypedSocket } from "./socket-interface"
+import type { StandardSchemaV1 } from "./standard-schema"
+
+export type SocketListeners<T extends TypedSocket> = T extends TypedSocket<
+	infer ListenEvents
+>
+	? ListenEvents
+	: never
+
+export type SocketGuard<L extends EventsMap> = {
+	[K in keyof L]: StandardSchemaV1<Json.Array, Parameters<L[K]>>
+}
+
+export type Loaded<L extends Loadable<any>> = L extends Loadable<infer T>
+	? T
+	: never
+
+function onLoad<L extends Loadable<any>>(
+	loadable: L,
+	fn: (loaded: Loaded<L>) => any,
+): void {
+	if (loadable instanceof Promise) {
+		void loadable.then(fn)
+	} else {
+		fn(loadable as Loaded<L>)
+	}
+}
+
+export function castSocket<T extends TypedSocket>(
+	socket: Socket,
+	guard: SocketGuard<SocketListeners<T>> | `TRUST`,
+	logError?: (error: unknown) => void,
+): T {
+	if (guard === `TRUST`) {
+		return socket as T
+	}
+	const guardedSocket: Socket = {
+		id: socket.id,
+		on: (event, listener) => {
+			const schema = guard[event] as StandardSchemaV1<Json.Array, Json.Array>
+			socket.on(event, (...args) => {
+				const loadableResult = schema[`~standard`].validate(args)
+				onLoad(loadableResult, (result) => {
+					if (result.issues) {
+						logError?.(result.issues)
+					} else {
+						listener(...result.value)
+					}
+				})
+			})
+		},
+		onAny: (listener) => {
+			socket.onAny((event, ...args) => {
+				const schema = guard[event] as StandardSchemaV1<unknown, Json.Array>
+				const loadableResult = schema[`~standard`].validate(args)
+				onLoad(loadableResult, (result) => {
+					if (result.issues) {
+						logError?.(result.issues)
+					} else {
+						listener(event, ...result.value)
+					}
+				})
+			})
+		},
+		off: socket.off.bind(socket),
+		offAny: socket.offAny.bind(socket),
+		emit: socket.emit.bind(socket),
+	}
+	return guardedSocket as T
+}

package/src/realtime/index.ts

@@ -1,6 +1,8 @@
+export * from "./cast-socket"
 export * from "./employ-socket"
 export * from "./mutex-store"
 export * from "./realtime-continuity"
 export * from "./realtime-key-types"
 export * from "./shared-room-store"
 export type * from "./socket-interface"
+export type * from "./standard-schema"

package/src/realtime/socket-interface.ts

@@ -20,7 +20,7 @@ export type AllEventsListener<ListenEvents extends EventsMap = EventsMap> = <
 ) => void
 
 export type EventEmitter<EmitEvents extends EventsMap = EventsMap> = <
-	E extends keyof EmitEvents,
+	E extends string & keyof EmitEvents,
 >(
 	event: E,
 	...args: Parameters<EmitEvents[E]>

package/src/realtime/standard-schema.ts

@@ -0,0 +1,72 @@
+/* eslint-disable quotes */
+
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+	/** The Standard Schema properties. */
+	readonly "~standard": StandardSchemaV1.Props<Input, Output>
+}
+
+export declare namespace StandardSchemaV1 {
+	/** The Standard Schema properties interface. */
+	export interface Props<Input = unknown, Output = Input> {
+		/** The version number of the standard. */
+		readonly version: 1
+		/** The vendor name of the schema library. */
+		readonly vendor: string
+		/** Validates unknown input values. */
+		readonly validate: (
+			value: unknown,
+		) => Promise<Result<Output>> | Result<Output>
+		/** Inferred types associated with the schema. */
+		readonly types?: Types<Input, Output> | undefined
+	}
+
+	/** The result interface of the validate function. */
+	export type Result<Output> = FailureResult | SuccessResult<Output>
+
+	/** The result interface if validation succeeds. */
+	export interface SuccessResult<Output> {
+		/** The typed output value. */
+		readonly value: Output
+		/** The non-existent issues. */
+		readonly issues?: undefined
+	}
+
+	/** The result interface if validation fails. */
+	export interface FailureResult {
+		/** The issues of failed validation. */
+		readonly issues: ReadonlyArray<Issue>
+	}
+
+	/** The issue interface of the failure output. */
+	export interface Issue {
+		/** The error message of the issue. */
+		readonly message: string
+		/** The path of the issue, if any. */
+		readonly path?: ReadonlyArray<PathSegment | PropertyKey> | undefined
+	}
+
+	/** The path segment interface of the issue. */
+	export interface PathSegment {
+		/** The key representing a path segment. */
+		readonly key: PropertyKey
+	}
+
+	/** The Standard Schema types interface. */
+	export interface Types<Input = unknown, Output = Input> {
+		/** The input type of the schema. */
+		readonly input: Input
+		/** The output type of the schema. */
+		readonly output: Output
+	}
+
+	/** Infers the input type of a Standard Schema. */
+	export type InferInput<Schema extends StandardSchemaV1> = NonNullable<
+		Schema["~standard"]["types"]
+	>["input"]
+
+	/** Infers the output type of a Standard Schema. */
+	export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<
+		Schema["~standard"]["types"]
+	>["output"]
+}

package/src/realtime-react/index.ts

@@ -6,6 +6,7 @@ export * from "./use-pull-mutable-family-member"
 export * from "./use-pull-selector"
 export * from "./use-pull-selector-family-member"
 export * from "./use-push"
+export * from "./use-realtime-rooms"
 export * from "./use-realtime-service"
 export * from "./use-single-effect"
 export * from "./use-sync-continuity"

package/src/realtime-react/realtime-context.tsx

@@ -1,5 +1,4 @@
 import { useI } from "atom.io/react"
-import type { RoomSocketInterface } from "atom.io/realtime"
 import * as RTC from "atom.io/realtime-client"
 import * as React from "react"
 import type { Socket } from "socket.io-client"
@@ -43,11 +42,3 @@ export const RealtimeProvider: React.FC<{
 		</RealtimeContext.Provider>
 	)
 }
-
-export function useRealtimeRooms<RoomNames extends string>(): Socket<
-	{},
-	RoomSocketInterface<RoomNames>
-> {
-	const { socket } = React.useContext(RealtimeContext)
-	return socket as Socket<{}, RoomSocketInterface<RoomNames>>
-}

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

@@ -0,0 +1,13 @@
+import type { RoomSocketInterface } from "atom.io/realtime"
+import * as React from "react"
+import type { Socket } from "socket.io-client"
+
+import { RealtimeContext } from "./realtime-context"
+
+export function useRealtimeRooms<RoomNames extends string>(): Socket<
+	{},
+	RoomSocketInterface<RoomNames>
+> {
+	const { socket } = React.useContext(RealtimeContext)
+	return socket as Socket<{}, RoomSocketInterface<RoomNames>>
+}

package/src/realtime-server/realtime-server-stores/index.ts

@@ -1,2 +1,2 @@
-export * from "./server-room-external-store"
+export * from "./provide-rooms"
 export * from "./server-user-store"

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

@@ -0,0 +1,368 @@
+import type { ChildProcessWithoutNullStreams } from "node:child_process"
+import { spawn } from "node:child_process"
+
+import type { RootStore } from "atom.io/internal"
+import {
+	editRelationsInStore,
+	findInStore,
+	findRelationsInStore,
+	getFromStore,
+	getInternalRelationsFromStore,
+	IMPLICIT,
+	setIntoStore,
+} from "atom.io/internal"
+import type { Json } from "atom.io/json"
+import type {
+	AllEventsListener,
+	EventsMap,
+	RoomKey,
+	RoomSocketInterface,
+	Socket,
+	SocketGuard,
+	SocketKey,
+	StandardSchemaV1,
+	TypedSocket,
+	UserKey,
+} from "atom.io/realtime"
+import {
+	castSocket,
+	isRoomKey,
+	ownersOfRooms,
+	roomKeysAtom,
+	usersInRooms,
+} from "atom.io/realtime"
+
+import { ChildSocket } from "../ipc-sockets"
+import { realtimeMutableFamilyProvider } from "../realtime-mutable-family-provider"
+import { realtimeMutableProvider } from "../realtime-mutable-provider"
+import type { ServerConfig } from "../server-config"
+import {
+	selfListSelectors,
+	socketKeysAtom,
+	userKeysAtom,
+	usersOfSockets,
+} from "./server-user-store"
+
+export type RoomMap = Map<
+	string,
+	ChildSocket<any, any, ChildProcessWithoutNullStreams>
+>
+
+declare global {
+	var ATOM_IO_REALTIME_SERVER_ROOMS: RoomMap
+}
+export const ROOMS: RoomMap =
+	globalThis.ATOM_IO_REALTIME_SERVER_ROOMS ??
+	(globalThis.ATOM_IO_REALTIME_SERVER_ROOMS = new Map())
+
+export const roomMeta: { count: number } = { count: 0 }
+
+export type SpawnRoomConfig<RoomNames extends string> = {
+	store: RootStore
+	socket: Socket
+	userKey: UserKey
+	resolveRoomScript: (roomName: RoomNames) => [string, string[]]
+}
+export function spawnRoom<RoomNames extends string>({
+	store,
+	socket,
+	userKey,
+	resolveRoomScript,
+}: SpawnRoomConfig<RoomNames>): (
+	roomName: RoomNames,
+) => Promise<ChildSocket<any, any>> {
+	return async (roomName) => {
+		store.logger.info(
+			`📡`,
+			`socket`,
+			socket.id ?? `[ID MISSING?!]`,
+			`👤 ${userKey} spawns room ${roomName}`,
+		)
+		const roomKey = `room::${roomMeta.count++}` satisfies RoomKey
+		const [command, args] = resolveRoomScript(roomName)
+		const child = await new Promise<ChildProcessWithoutNullStreams>(
+			(resolve) => {
+				const room = spawn(command, args, { env: process.env })
+				const resolver = (data: Buffer) => {
+					if (data.toString() === `ALIVE`) {
+						room.stdout.off(`data`, resolver)
+						resolve(room)
+					}
+				}
+				room.stdout.on(`data`, resolver)
+			},
+		)
+		const roomSocket = new ChildSocket(child, roomKey)
+		ROOMS.set(roomKey, roomSocket)
+		setIntoStore(store, roomKeysAtom, (index) => (index.add(roomKey), index))
+
+		editRelationsInStore(store, ownersOfRooms, (relations) => {
+			relations.set({ room: roomKey, user: userKey })
+		})
+
+		roomSocket.on(`close`, () => {
+			destroyRoom({ store, socket, userKey })(roomKey)
+		})
+
+		return roomSocket
+	}
+}
+
+export type ProvideEnterAndExitConfig = {
+	store: RootStore
+	socket: Socket
+	roomSocket: TypedSocket<RoomSocketInterface<any>, any>
+	userKey: UserKey
+}
+export function provideEnterAndExit({
+	store,
+	socket,
+	roomSocket,
+	userKey,
+}: ProvideEnterAndExitConfig): (roomKey: RoomKey) => void {
+	const enterRoom = (roomKey: RoomKey) => {
+		store.logger.info(
+			`📡`,
+			`socket`,
+			socket.id ?? `[ID MISSING?!]`,
+			`👤 ${userKey} enters room ${roomKey}`,
+		)
+
+		const exitRoom = () => {
+			store.logger.info(
+				`📡`,
+				`socket`,
+				socket.id ?? `[ID MISSING?!]`,
+				`👤 ${userKey} leaves room ${roomKey}`,
+			)
+			socket.offAny(forward)
+			toRoom([`user-leaves`])
+			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)
+		}
+		let toRoom = pushToRoomQueue
+		const forward: AllEventsListener<EventsMap> = (...payload) => {
+			toRoom(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 null
+		}
+		childSocket.onAny((...payload) => {
+			socket.emit(...payload)
+		})
+		childSocket.emit(`user-joins`, userKey)
+
+		toRoom = (payload) => {
+			childSocket.emit(`user::${userKey}`, ...payload)
+		}
+		while (roomQueue.length > 0) {
+			const payload = roomQueue.shift()
+			if (payload) toRoom(payload)
+		}
+	}
+	roomSocket.on(`joinRoom`, enterRoom)
+	return enterRoom
+}
+
+export type DestroyRoomConfig = {
+	store: RootStore
+	socket: Socket
+	userKey: UserKey
+}
+export function destroyRoom({
+	store,
+	socket,
+	userKey,
+}: DestroyRoomConfig): (roomKey: RoomKey) => void {
+	return (roomKey: RoomKey) => {
+		store.logger.info(
+			`📡`,
+			`socket`,
+			socket.id ?? `[ID MISSING?!]`,
+			`👤 ${userKey} attempts to delete room ${roomKey}`,
+		)
+		const owner = getFromStore(
+			store,
+			findRelationsInStore(store, ownersOfRooms, roomKey).userKeyOfRoom,
+		)
+		if (owner === userKey) {
+			store.logger.info(
+				`📡`,
+				`socket`,
+				socket.id ?? `[ID MISSING?!]`,
+				`👤 ${userKey} deletes room ${roomKey}`,
+			)
+			setIntoStore(store, roomKeysAtom, (s) => (s.delete(roomKey), s))
+			editRelationsInStore(store, usersInRooms, (relations) => {
+				relations.delete({ room: roomKey })
+			})
+			const room = ROOMS.get(roomKey)
+			if (room) {
+				room.emit(`exit`)
+				ROOMS.delete(roomKey)
+			}
+			return
+		}
+		store.logger.info(
+			`📡`,
+			`socket`,
+			socket.id ?? `[ID MISSING?!]`,
+			`👤 ${userKey} failed to delete room ${roomKey}; room owner is ${owner}`,
+		)
+	}
+}
+
+export type ProvideRoomsConfig<RoomNames extends string> = {
+	resolveRoomScript: (path: RoomNames) => [string, string[]]
+	roomNames: RoomNames[]
+	roomTimeLimit?: number
+}
+export function provideRooms<RoomNames extends string>({
+	store = IMPLICIT.STORE,
+	socket,
+	resolveRoomScript,
+	roomNames,
+}: ProvideRoomsConfig<RoomNames> & ServerConfig): void {
+	const socketKey = `socket::${socket.id}` satisfies SocketKey
+	const userKey = getFromStore(
+		store,
+		findRelationsInStore(store, usersOfSockets, socketKey).userKeyOfSocket,
+	)!
+	// const roomSocket = socket as TypedSocket<RoomSocketInterface<RoomNames>, {}>
+	const roomSocket = castSocket<TypedSocket<RoomSocketInterface<RoomNames>, {}>>(
+		socket,
+		createRoomSocketGuard(roomNames),
+	)
+
+	const exposeMutable = realtimeMutableProvider({ socket, store })
+	const exposeMutableFamily = realtimeMutableFamilyProvider({
+		socket,
+		store,
+	})
+
+	exposeMutable(roomKeysAtom)
+
+	const [, usersInRoomsAtoms] = getInternalRelationsFromStore(
+		store,
+		usersInRooms,
+		`split`,
+	)
+	const usersWhoseRoomsCanBeSeenSelector = findInStore(
+		store,
+		selfListSelectors,
+		userKey,
+	)
+	exposeMutableFamily(usersInRoomsAtoms, usersWhoseRoomsCanBeSeenSelector)
+	const usersOfSocketsAtoms = getInternalRelationsFromStore(
+		store,
+		usersOfSockets,
+	)
+	exposeMutableFamily(usersOfSocketsAtoms, socketKeysAtom)
+
+	const enterRoom = provideEnterAndExit({ store, socket, roomSocket, userKey })
+
+	const userRoomSet = getFromStore(store, usersInRoomsAtoms, userKey)
+	for (const userRoomKey of userRoomSet) {
+		enterRoom(userRoomKey)
+		break
+	}
+
+	roomSocket.on(
+		`createRoom`,
+		spawnRoom({ store, socket, userKey, resolveRoomScript }),
+	)
+	roomSocket.on(`deleteRoom`, destroyRoom({ store, socket, userKey }))
+	socket.on(`disconnect`, () => {
+		store.logger.info(
+			`📡`,
+			`socket`,
+			socket.id ?? `[ID MISSING?!]`,
+			`👤 ${userKey} disconnects`,
+		)
+		editRelationsInStore(store, usersOfSockets, (rel) => rel.delete(socketKey))
+		setIntoStore(store, userKeysAtom, (keys) => (keys.delete(userKey), keys))
+		setIntoStore(store, socketKeysAtom, (keys) => (keys.delete(socketKey), keys))
+	})
+}
+
+const roomKeySchema: StandardSchemaV1<Json.Array, [RoomKey]> = {
+	"~standard": {
+		version: 1,
+		vendor: `atom.io`,
+		validate: ([maybeRoomKey]: Json.Array) => {
+			if (typeof maybeRoomKey === `string`) {
+				if (isRoomKey(maybeRoomKey)) {
+					return { value: [maybeRoomKey] }
+				}
+				return {
+					issues: [
+						{
+							message: `Room key must start with "room::"`,
+						},
+					],
+				}
+			}
+			return {
+				issues: [
+					{
+						message: `Room key must be a string`,
+					},
+				],
+			}
+		},
+	},
+}
+
+function createRoomSocketGuard<RoomNames extends string>(
+	roomNames: RoomNames[],
+): SocketGuard<RoomSocketInterface<RoomNames>> {
+	return {
+		createRoom: {
+			"~standard": {
+				version: 1,
+				vendor: `atom.io`,
+				validate: ([maybeRoomName]) => {
+					if (roomNames.includes(maybeRoomName as RoomNames)) {
+						return { value: [maybeRoomName as RoomNames] }
+					}
+					return {
+						issues: [
+							{
+								message:
+									`Room name must be one of the following:\n - ` +
+									roomNames.join(`\n - `),
+							},
+						],
+					}
+				},
+			},
+		},
+		joinRoom: roomKeySchema,
+		deleteRoom: roomKeySchema,
+		leaveRoom: {
+			"~standard": {
+				version: 1,
+				vendor: `atom.io`,
+				validate: () => ({ value: [] }),
+			},
+		},
+	}
+}