atom.io 0.40.6 → 0.40.8

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

@@ -1,17 +1,21 @@
+import type { Readable, Writable } from "node:stream"
+
 import { Subject } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 import { parseJson, stringifyJson } from "atom.io/json"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 
-import type { EventBuffer, Events } from "./custom-socket"
+import type { UserKey } from "../realtime-server-stores"
+import type { StderrLog } from "./child-socket"
+import type { EventBuffer, EventPayload, Events } from "./custom-socket"
 import { CustomSocket } from "./custom-socket"
 
 export class SubjectSocket<
 	I extends Events,
 	O extends Events,
 > extends CustomSocket<I, O> {
-	public in: Subject<[string, ...Json.Serializable[]]>
-	public out: Subject<[string, ...Json.Serializable[]]>
+	public in: Subject<EventPayload<I>>
+	public out: Subject<EventPayload<O>>
 	public id = `no_id_retrieved`
 	public disposalFunctions: (() => void)[] = []
 
@@ -24,7 +28,7 @@ export class SubjectSocket<
 		this.in = new Subject()
 		this.out = new Subject()
 		this.in.subscribe(`socket`, (event) => {
-			this.handleEvent(...(event as [string, ...I[keyof I]]))
+			this.handleEvent(...event)
 		})
 	}
 
@@ -35,31 +39,41 @@ export class SubjectSocket<
 	}
 }
 
+export type ParentProcess = {
+	pid?: number | undefined
+	stdin: Readable
+	stdout: Writable
+	stderr: Writable
+	exit: (code?: number) => void
+}
+
 export class ParentSocket<
 	I extends Events & {
-		[id in string as `relay:${id}`]: [string, ...Json.Serializable[]]
+		[id in string as `relay::${id}`]: [string, ...Json.Array[]]
 	},
 	O extends Events & {
-		[id in string as `user:${id}`]: [string, ...Json.Serializable[]]
+		[id in string as `user::${id}`]: [string, ...Json.Array[]]
 	} & {
 		/* eslint-disable quotes */
-		"user-joins": [string]
-		"user-leaves": [string]
+		"user-joins": [key: UserKey]
+		"user-leaves": [key: UserKey]
 		/* eslint-enable quotes */
 	},
+	P extends ParentProcess = ParentProcess,
 > extends CustomSocket<I, O> {
 	protected incompleteData = ``
 	protected unprocessedEvents: string[] = []
 	protected relays: Map<string, SubjectSocket<any, any>>
 	protected relayServices: ((
 		socket: SubjectSocket<any, any>,
+		userKey: UserKey,
 	) => (() => void) | void)[]
-	protected process: NodeJS.Process
+	public proc: P
 
 	public id = `#####`
 
-	protected log(...args: any[]): void {
-		this.process.stderr.write(
+	protected log(...args: StderrLog): void {
+		this.proc.stderr.write(
 			stringifyJson(
 				args.map((arg) =>
 					arg instanceof SetRTX
@@ -70,100 +84,112 @@ export class ParentSocket<
 		)
 	}
 	public logger = {
-		info: (...args: any[]): void => {
+		info: (...args: Json.Array): void => {
 			this.log(`i`, ...args)
 		},
-		warn: (...args: any[]): void => {
+		warn: (...args: Json.Array): void => {
 			this.log(`w`, ...args)
 		},
-		error: (...args: any[]): void => {
+		error: (...args: Json.Array): void => {
 			this.log(`e`, ...args)
 		},
 	}
 
-	public constructor() {
+	public constructor(proc: P) {
 		super((event, ...args) => {
 			const stringifiedEvent = JSON.stringify([event, ...args])
-			this.process.stdout.write(stringifiedEvent + `\x03`)
+			this.proc.stdout.write(stringifiedEvent + `\x03`)
 			return this
 		})
-		this.process = process
-		this.process.stdin.resume()
+		this.proc = proc
+		this.proc.stdin.resume()
 		this.relays = new Map()
 		this.relayServices = []
-		// this.logger.info(`🔗`, `uplink`, process.pid)
 
-		this.process.stdin.on(
+		this.proc.stdin.on(
 			`data`,
-			<Event extends keyof I>(buffer: EventBuffer<string, I[Event]>) => {
+			<K extends string & keyof I>(buffer: EventBuffer<I, K>) => {
 				const chunk = buffer.toString()
-				this.unprocessedEvents.push(...chunk.split(`\x03`))
-				const newInput = this.unprocessedEvents.shift()
-				this.incompleteData += newInput ?? ``
-
-				try {
-					const parsedData = parseJson(this.incompleteData)
-					this.logger.info(`🎰`, `received`, parsedData)
-					this.handleEvent(...(parsedData as [string, ...I[keyof I]]))
-					while (this.unprocessedEvents.length > 0) {
-						const event = this.unprocessedEvents.shift()
-						if (event) {
-							if (this.unprocessedEvents.length === 0) {
-								this.incompleteData = event
+				const pieces = chunk.split(`\x03`)
+				const initialMaybeWellFormed = pieces[0]
+				pieces[0] = this.incompleteData + initialMaybeWellFormed
+				let idx = 0
+				for (const piece of pieces) {
+					if (piece === ``) {
+						continue
+					}
+					try {
+						const jsonPiece = parseJson(piece)
+						this.logger.info(`🎰`, `received`, jsonPiece)
+						this.handleEvent(...(jsonPiece as EventPayload<I>))
+						this.incompleteData = ``
+					} catch (thrown0) {
+						if (thrown0 instanceof Error) {
+							this.logger.error(
+								[
+									`received malformed data from parent process:`,
+									``,
+									piece,
+									``,
+									thrown0.message,
+								].join(`\n❌\t`),
+							)
+						}
+						try {
+							if (idx === 0) {
+								this.incompleteData = piece
+								const maybeActualJsonPiece = parseJson(initialMaybeWellFormed)
+								this.logger.info(`🎰`, `received`, maybeActualJsonPiece)
+								this.handleEvent(...(maybeActualJsonPiece as EventPayload<I>))
+								this.incompleteData = ``
+							} else {
+								this.incompleteData += piece
+							}
+						} catch (thrown1) {
+							if (thrown1 instanceof Error) {
+								this.logger.error(
+									[
+										`received malformed data from parent process:`,
+										``,
+										initialMaybeWellFormed,
+										``,
+										thrown1.message,
+									].join(`\n❌\t`),
+								)
 							}
-							const parsedEvent = parseJson(event)
-							this.handleEvent(...(parsedEvent as [string, ...I[keyof I]]))
 						}
 					}
-					this.incompleteData = ``
-				} catch (thrown) {
-					if (thrown instanceof Error) {
-						this.logger.error(`❗`, thrown.message, thrown.cause, thrown.stack)
-					}
+					++idx
 				}
 			},
 		)
 
 		this.on(`exit`, () => {
 			this.logger.info(`🔥`, this.id, `received "exit"`)
-			process.exit(0)
-		})
-		process.on(`exit`, (code) => {
-			this.logger.info(`🔥`, this.id, `exited with code ${code}`)
-		})
-		process.on(`end`, () => {
-			this.logger.info(`🔥`, this.id, `ended`)
-			process.exit(0)
-		})
-		process.on(`SIGTERM`, () => {
-			this.logger.error(`🔥`, this.id, `terminated`)
-			process.exit(0)
-		})
-		process.on(`SIGINT`, () => {
-			this.logger.error(`🔥`, this.id, `interrupted`)
-			process.exit(0)
+			this.proc.exit(0)
 		})
 
-		if (process.pid) {
-			this.id = process.pid?.toString()
+		if (this.proc.pid) {
+			this.id = this.proc.pid?.toString()
 		}
 
-		this.on(`user-joins`, (username) => {
+		this.on(`user-joins`, (username: string) => {
 			this.logger.info(`👤`, `user`, username, `joined`)
-			const relay = new SubjectSocket(`user:${username}`)
+			const userKey = `user::${username}` satisfies UserKey
+			const relay = new SubjectSocket(userKey)
 			this.relays.set(username, relay)
 			this.logger.info(
 				`🔗`,
 				`attaching services:`,
 				`[${[...this.relayServices.keys()].join(`, `)}]`,
 			)
-			for (const attachServices of this.relayServices) {
-				const cleanup = attachServices(relay)
-				if (cleanup) {
-					relay.disposalFunctions.push(cleanup)
+			for (const attachRelay of this.relayServices) {
+				const cleanupRelay = attachRelay(relay, userKey)
+				if (cleanupRelay) {
+					relay.disposalFunctions.push(cleanupRelay)
 				}
 			}
-			this.on(`user:${username}`, (...data) => {
+			this.on(userKey, (...data) => {
 				relay.in.next(data)
 			})
 			relay.out.subscribe(`socket`, (data) => {
@@ -180,11 +206,14 @@ export class ParentSocket<
 			}
 		})
 
-		process.stdout.write(`ALIVE`)
+		this.proc.stdout.write(`ALIVE`)
 	}
 
-	public relay(
-		attachServices: (socket: SubjectSocket<any, any>) => (() => void) | void,
+	public receiveRelay(
+		attachServices: (
+			socket: SubjectSocket<any, any>,
+			userKey: UserKey,
+		) => (() => void) | void,
 	): void {
 		this.logger.info(`🔗`, `running relay method`)
 		this.relayServices.push(attachServices)

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

@@ -5,10 +5,11 @@ import {
 	IMPLICIT,
 	subscribeToState,
 } from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical, Json, stringified } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import type { ServerConfig } from "."
+import { employSocket } from "./employ-socket"
 
 export type FamilyProvider = ReturnType<typeof realtimeAtomFamilyProvider>
 export function realtimeAtomFamilyProvider({
@@ -22,49 +23,97 @@ export function realtimeAtomFamilyProvider({
 		family: AtomIO.RegularAtomFamilyToken<J, K>,
 		index: AtomIO.ReadableToken<Iterable<K>>,
 	): () => void {
-		const unsubCallbacksByKey = new Map<string, () => void>()
+		const coreSubscriptions = new Set<() => void>()
+		const clearCoreSubscriptions = () => {
+			for (const unsub of coreSubscriptions) unsub()
+			coreSubscriptions.clear()
+		}
+		const familyMemberSubscriptionsWanted = new Set<stringified<K>>()
+		const familyMemberSubscriptions = new Map<string, () => void>()
+		const clearFamilySubscriptions = () => {
+			for (const unsub of familyMemberSubscriptions.values()) unsub()
+			familyMemberSubscriptions.clear()
+		}
 
 		const fillUnsubRequest = (key: string) => {
-			socket.off(`unsub:${key}`, fillUnsubRequest)
-			const unsub = unsubCallbacksByKey.get(key)
+			const unsubUnsub = familyMemberSubscriptions.get(`${key}:unsub`)
+			if (unsubUnsub) {
+				unsubUnsub()
+				familyMemberSubscriptions.delete(`${key}:unsub`)
+			}
+			const unsub = familyMemberSubscriptions.get(key)
 			if (unsub) {
 				unsub()
-				unsubCallbacksByKey.delete(key)
+				familyMemberSubscriptions.delete(key)
 			}
 		}
 
-		const fillSubRequest = (subKey: K) => {
-			const exposedSubKeys = getFromStore(store, index)
+		const exposeFamilyMembers = (subKey: K) => {
+			const token = findInStore(store, family, subKey)
+			getFromStore(store, token)
+			socket.emit(`serve:${token.key}`, getFromStore(store, token))
+			familyMemberSubscriptions.set(
+				token.key,
+				subscribeToState(
+					store,
+					token,
+					`expose-family:${family.key}:${socket.id}`,
+					({ newValue }) => {
+						socket.emit(`serve:${token.key}`, newValue)
+					},
+				),
+			)
+			familyMemberSubscriptions.set(
+				`${token.key}:unsub`,
+				employSocket(socket, `unsub:${token.key}`, () => {
+					fillUnsubRequest(token.key)
+				}),
+			)
+		}
+
+		const isAvailable = (exposedSubKeys: Iterable<K>, subKey: K): boolean => {
 			for (const exposedSubKey of exposedSubKeys) {
 				if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) {
-					const token = findInStore(store, family, subKey)
-					socket.emit(`serve:${token.key}`, getFromStore(store, token))
-					const unsubscribe = subscribeToState(
-						store,
-						token,
-						`expose-family:${family.key}:${socket.id}`,
-						({ newValue }) => {
-							socket.emit(`serve:${token.key}`, newValue)
-						},
-					)
-					unsubCallbacksByKey.set(token.key, unsubscribe)
-					socket.on(`unsub:${token.key}`, () => {
-						fillUnsubRequest(token.key)
-					})
-					break
+					return true
 				}
 			}
+			return false
 		}
 
-		socket.on(`sub:${family.key}`, fillSubRequest)
+		const start = () => {
+			coreSubscriptions.add(
+				employSocket(socket, `sub:${family.key}`, (subKey: K) => {
+					const exposedSubKeys = getFromStore(store, index)
+					const shouldExpose = isAvailable(exposedSubKeys, subKey)
+					if (shouldExpose) {
+						exposeFamilyMembers(subKey)
+					} else {
+						familyMemberSubscriptionsWanted.add(stringifyJson(subKey))
+						socket.emit(`unavailable:${family.key}`, subKey)
+					}
+				}),
+			)
+			coreSubscriptions.add(
+				subscribeToState(
+					store,
+					index,
+					`expose-family:${family.key}:${socket.id}`,
+					({ newValue: newExposedSubKeys }) => {
+						for (const subKey of newExposedSubKeys) {
+							if (familyMemberSubscriptionsWanted.has(stringifyJson(subKey))) {
+								exposeFamilyMembers(subKey)
+							}
+						}
+					},
+				),
+			)
+		}
 
-		return () => {
-			socket.off(`sub:${family.key}`, fillSubRequest)
+		start()
 
-			for (const [, unsub] of unsubCallbacksByKey) {
-				unsub()
-			}
-			unsubCallbacksByKey.clear()
+		return () => {
+			clearCoreSubscriptions()
+			clearFamilySubscriptions()
 		}
 	}
 }

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

@@ -8,10 +8,11 @@ import {
 	IMPLICIT,
 	subscribeToState,
 } from "atom.io/internal"
-import type { Canonical } from "atom.io/json"
+import type { Canonical, stringified } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import type { ServerConfig } from "."
+import { employSocket } from "./employ-socket"
 
 export type MutableFamilyProvider = ReturnType<
 	typeof realtimeMutableFamilyProvider
@@ -27,51 +28,99 @@ export function realtimeMutableFamilyProvider({
 		family: AtomIO.MutableAtomFamilyToken<T, K>,
 		index: AtomIO.ReadableToken<Iterable<K>>,
 	): () => void {
-		const unsubCallbacksByKey = new Map<string, () => void>()
+		const coreSubscriptions = new Set<() => void>()
+		const clearCoreSubscriptions = () => {
+			for (const unsub of coreSubscriptions) unsub()
+			coreSubscriptions.clear()
+		}
+		const familyMemberSubscriptionsWanted = new Set<stringified<K>>()
+		const familyMemberSubscriptions = new Map<string, () => void>()
+		const clearFamilySubscriptions = () => {
+			for (const unsub of familyMemberSubscriptions.values()) unsub()
+			familyMemberSubscriptions.clear()
+		}
 
 		const fillUnsubRequest = (key: string) => {
-			socket.off(`unsub:${key}`, fillUnsubRequest)
-			const unsub = unsubCallbacksByKey.get(key)
+			const unsubUnsub = familyMemberSubscriptions.get(`${key}:unsub`)
+			if (unsubUnsub) {
+				unsubUnsub()
+				familyMemberSubscriptions.delete(`${key}:unsub`)
+			}
+			const unsub = familyMemberSubscriptions.get(key)
 			if (unsub) {
 				unsub()
-				unsubCallbacksByKey.delete(key)
+				familyMemberSubscriptions.delete(key)
 			}
 		}
 
-		const fillSubRequest = (subKey: K) => {
-			const exposedSubKeys = getFromStore(store, index)
+		const exposeFamilyMembers = (subKey: K) => {
+			const token = findInStore(store, family, subKey)
+			getFromStore(store, token)
+			const jsonToken = getJsonToken(store, token)
+			const updateToken = getUpdateToken(token)
+			socket.emit(`init:${token.key}`, getFromStore(store, jsonToken))
+			familyMemberSubscriptions.set(
+				token.key,
+				subscribeToState(
+					store,
+					updateToken,
+					`expose-family:${family.key}:${socket.id}`,
+					({ newValue }) => {
+						socket.emit(`next:${token.key}`, newValue)
+					},
+				),
+			)
+			familyMemberSubscriptions.set(
+				`${token.key}:unsub`,
+				employSocket(socket, `unsub:${token.key}`, () => {
+					fillUnsubRequest(token.key)
+				}),
+			)
+		}
+
+		const isAvailable = (exposedSubKeys: Iterable<K>, subKey: K): boolean => {
 			for (const exposedSubKey of exposedSubKeys) {
 				if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) {
-					const token = findInStore(store, family, subKey)
-					getFromStore(store, token)
-					const jsonToken = getJsonToken(store, token)
-					const updateToken = getUpdateToken(token)
-					socket.emit(`init:${token.key}`, getFromStore(store, jsonToken))
-					const unsubscribe = subscribeToState(
-						store,
-						updateToken,
-						`expose-family:${family.key}:${socket.id}`,
-						({ newValue }) => {
-							socket.emit(`next:${token.key}`, newValue)
-						},
-					)
-					unsubCallbacksByKey.set(token.key, unsubscribe)
-					socket.on(`unsub:${token.key}`, () => {
-						fillUnsubRequest(token.key)
-					})
-					break
+					return true
 				}
 			}
+			return false
 		}
 
-		socket.on(`sub:${family.key}`, fillSubRequest)
+		const start = () => {
+			coreSubscriptions.add(
+				employSocket(socket, `sub:${family.key}`, (subKey: K) => {
+					const exposedSubKeys = getFromStore(store, index)
+					const shouldExpose = isAvailable(exposedSubKeys, subKey)
+					if (shouldExpose) {
+						exposeFamilyMembers(subKey)
+					} else {
+						familyMemberSubscriptionsWanted.add(stringifyJson(subKey))
+						socket.emit(`unavailable:${family.key}`, subKey)
+					}
+				}),
+			)
+			coreSubscriptions.add(
+				subscribeToState(
+					store,
+					index,
+					`expose-family:${family.key}:${socket.id}`,
+					({ newValue: newExposedSubKeys }) => {
+						for (const subKey of newExposedSubKeys) {
+							if (familyMemberSubscriptionsWanted.has(stringifyJson(subKey))) {
+								exposeFamilyMembers(subKey)
+							}
+						}
+					},
+				),
+			)
+		}
+
+		start()
 
 		return () => {
-			socket.off(`sub:${family.key}`, fillSubRequest)
-			for (const [, unsub] of unsubCallbacksByKey) {
-				unsub()
-			}
-			unsubCallbacksByKey.clear()
+			clearCoreSubscriptions()
+			clearFamilySubscriptions()
 		}
 	}
 }

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

@@ -10,6 +10,7 @@ import {
 import type { Json } from "atom.io/json"
 
 import type { ServerConfig } from "."
+import { employSocket } from "./employ-socket"
 
 export type MutableProvider = ReturnType<typeof realtimeMutableProvider>
 export function realtimeMutableProvider({
@@ -19,35 +20,42 @@ export function realtimeMutableProvider({
 	return function mutableProvider<
 		Core extends Transceiver<any, Json.Serializable, Json.Serializable>,
 	>(token: AtomIO.MutableAtomToken<Core>): () => void {
-		let unsubscribeFromStateUpdates: (() => void) | null = null
+		const subscriptions = new Set<() => void>()
+		const clearSubscriptions = () => {
+			for (const unsub of subscriptions) unsub()
+			subscriptions.clear()
+		}
 
 		const jsonToken = getJsonToken(store, token)
 		const trackerToken = getUpdateToken(token)
 
-		const fillUnsubRequest = () => {
-			socket.off(`unsub:${token.key}`, fillUnsubRequest)
-			unsubscribeFromStateUpdates?.()
-			unsubscribeFromStateUpdates = null
-		}
-
-		const fillSubRequest = () => {
-			socket.emit(`init:${token.key}`, getFromStore(store, jsonToken))
-			unsubscribeFromStateUpdates = subscribeToState(
-				store,
-				trackerToken,
-				`expose-single:${socket.id}`,
-				({ newValue }) => {
-					socket.emit(`next:${token.key}`, newValue)
-				},
+		const start = () => {
+			subscriptions.add(
+				employSocket(socket, `sub:${token.key}`, () => {
+					clearSubscriptions()
+					socket.emit(`init:${token.key}`, getFromStore(store, jsonToken))
+					subscriptions.add(
+						subscribeToState(
+							store,
+							trackerToken,
+							`expose-single:${socket.id}`,
+							({ newValue }) => {
+								socket.emit(`next:${token.key}`, newValue)
+							},
+						),
+					)
+					subscriptions.add(
+						employSocket(socket, `unsub:${token.key}`, () => {
+							clearSubscriptions()
+							start()
+						}),
+					)
+				}),
 			)
-			socket.on(`unsub:${token.key}`, fillUnsubRequest)
 		}
 
-		socket.on(`sub:${token.key}`, fillSubRequest)
+		start()
 
-		return () => {
-			socket.off(`sub:${token.key}`, fillSubRequest)
-			unsubscribeFromStateUpdates?.()
-		}
+		return clearSubscriptions
 	}
 }

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

@@ -1,4 +1,2 @@
-export * from "./server-room-external-actions"
 export * from "./server-room-external-store"
-export * from "./server-sync-store"
 export * from "./server-user-store"