atom.io 0.40.6 → 0.40.7

package/src/realtime-react/use-pull-selector-family-member.ts

@@ -7,15 +7,14 @@ import * as React from "react"
 
 import { useRealtimeService } from "./use-realtime-service"
 
-export function usePullSelectorFamilyMember<
-	T,
-	K extends Canonical,
-	Key extends K,
->(familyToken: AtomIO.SelectorFamilyToken<T, K>, key: Key): T {
+export function usePullSelectorFamilyMember<T, K extends Canonical>(
+	familyToken: AtomIO.SelectorFamilyToken<T, K>,
+	key: NoInfer<K>,
+): T {
 	const store = React.useContext(StoreContext)
 	const token = findInStore(store, familyToken, key)
 	useRealtimeService(`pull:${token.key}`, (socket) =>
-		RTC.pullSelectorFamilyMember(store, socket, token),
+		RTC.pullSelectorFamilyMember(store, socket, familyToken, key),
 	)
 
 	return useO(token)

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

@@ -1,6 +1,7 @@
 import type * as AtomIO from "atom.io"
 import type { Json } from "atom.io/json"
-import { StoreContext, useI } from "atom.io/react"
+import { StoreContext, useI, useO } from "atom.io/react"
+import * as RT from "atom.io/realtime"
 import * as RTC from "atom.io/realtime-client"
 import * as React from "react"
 
@@ -8,10 +9,13 @@ import { useRealtimeService } from "./use-realtime-service"
 
 export function usePush<J extends Json.Serializable>(
 	token: AtomIO.WritableToken<J>,
-): <New extends J>(next: New | ((old: J) => New)) => void {
+): (<New extends J>(next: New | ((old: J) => New)) => void) | null {
 	const store = React.useContext(StoreContext)
 	useRealtimeService(`push:${token.key}`, (socket) =>
 		RTC.pushState(store, socket, token),
 	)
-	return useI(token)
+	const mutex = useO(RT.mutexAtoms, token.key)
+	const setter = useI(token)
+
+	return mutex ? setter : null
 }

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

@@ -1,31 +1,31 @@
 import * as React from "react"
 import type { Socket } from "socket.io-client"
 
-import { onMount } from "./on-mount"
 import { RealtimeContext } from "./realtime-context"
+import { useSingleEffect } from "./use-single-effect"
 
 export function useRealtimeService(
 	key: string,
-	create: (socket: Socket) => (() => void) | undefined,
+	create: (socket: Socket) => () => void,
 ): void {
 	const { socket, services } = React.useContext(RealtimeContext)
-	onMount(() => {
+	useSingleEffect(() => {
 		let service = services?.get(key)
 		if (service) {
-			service[0]++
-		} else {
-			const dispose = socket ? create(socket) : undefined
-			service = [1, dispose]
+			++service.consumerCount
+		} else if (socket) {
+			const dispose = create(socket)
+			service = { consumerCount: 1, dispose }
 			services?.set(key, service)
 		}
 		return () => {
 			if (service) {
-				service[0]--
-				if (service[0] === 0) {
-					service[1]?.()
+				--service.consumerCount
+				if (service.consumerCount === 0) {
+					service.dispose?.()
 					services?.delete(key)
 				}
 			}
 		}
-	})
+	}, [socket, key])
 }

package/src/realtime-react/use-single-effect.ts

@@ -1,28 +1,25 @@
 /** biome-ignore-all lint/correctness/useHookAtTopLevel: intentional */
 
+import { isFn } from "atom.io/internal/is-fn"
 import * as React from "react"
 
-// @ts-expect-error this is a safe way to check a property on the global object
-const { NODE_ENV } = globalThis[`env`] ?? {}
-const IN_DEV = NODE_ENV === `development`
-
-function noop() {}
-
 export function useSingleEffect(
 	effect: () => (() => void) | undefined | void,
 	deps: unknown[],
 ): void {
-	if (IN_DEV) {
-		const cleanup = React.useRef<() => void>(noop)
+	const globalEnv = (globalThis as unknown as { env: any })[`env`]
+	const isInDev = globalEnv?.NODE_ENV === `development`
+	if (isInDev) {
+		const cleanupRef = React.useRef<boolean | (() => void)>(false)
 		React.useEffect(() => {
-			let dispose = cleanup.current
-			if (dispose === noop) {
-				dispose = effect() ?? noop
-				cleanup.current = dispose
+			let cleanupFn = cleanupRef.current
+			if (cleanupFn === false) {
+				cleanupFn = effect() ?? true
+				cleanupRef.current = cleanupFn
 			} else {
 				return () => {
-					dispose()
-					cleanup.current = noop
+					if (isFn(cleanupFn)) cleanupFn()
+					cleanupRef.current = false
 				}
 			}
 		}, deps)

package/src/realtime-server/{realtime-server-stores/server-sync-store.ts → continuity/continuity-store.ts}

@@ -5,7 +5,7 @@ import type {
 } from "atom.io"
 import { atomFamily } from "atom.io"
 
-import type { UserKey } from "./server-user-store"
+import type { UserKey } from "../realtime-server-stores/server-user-store"
 
 // export const completeUpdateAtoms = atomFamily<
 // 	TransactionUpdate<any> | null,

package/src/realtime-server/continuity/prepare-to-sync-realtime-continuity.ts

@@ -10,7 +10,7 @@ import type { ContinuityToken } from "atom.io/realtime"
 
 import type { ServerConfig, Socket } from ".."
 import { socketAtoms, usersOfSockets } from ".."
-import { userUnacknowledgedQueues } from "../realtime-server-stores"
+import { userUnacknowledgedQueues } from "./continuity-store"
 import { prepareToSendInitialPayload } from "./prepare-to-send-initial-payload"
 import { prepareToServeTransactionRequest } from "./prepare-to-serve-transaction-request"
 import { prepareToTrackClientAcknowledgement } from "./prepare-to-track-client-acknowledgement"

package/src/realtime-server/continuity/prepare-to-track-client-acknowledgement.ts

@@ -2,11 +2,9 @@ import type { Store } from "atom.io/internal"
 import { setIntoStore } from "atom.io/internal"
 import type { ContinuityToken } from "atom.io/realtime"
 
-import type {
-	ContinuitySyncTransactionUpdate,
-	UserKey,
-} from "../realtime-server-stores"
-import { userUnacknowledgedQueues } from "../realtime-server-stores"
+import type { UserKey } from "../realtime-server-stores"
+import type { ContinuitySyncTransactionUpdate } from "./continuity-store"
+import { userUnacknowledgedQueues } from "./continuity-store"
 
 export function prepareToTrackClientAcknowledgement(
 	store: Store,

package/src/realtime-server/continuity/subscribe-to-continuity-actions.ts

@@ -13,7 +13,7 @@ import type { Socket, UserKey } from ".."
 import {
 	redactTransactionUpdateContent,
 	userUnacknowledgedQueues,
-} from "../realtime-server-stores"
+} from "./continuity-store"
 
 export function subscribeToContinuityActions(
 	store: Store,

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

@@ -0,0 +1,14 @@
+import type { Events } from "./ipc-sockets"
+import type { Socket } from "./socket-interface"
+
+export function employSocket<I extends Events, K extends string & keyof I>(
+	socket: Socket,
+	event: K,
+	handleEvent: (...data: I[K]) => void,
+): () => void {
+	socket.on(event, handleEvent)
+	const retireSocket = () => {
+		socket.off(event, handleEvent)
+	}
+	return retireSocket
+}

package/src/realtime-server/index.ts

@@ -1,6 +1,3 @@
-import type { RootStore } from "atom.io/internal"
-import type { Json } from "atom.io/json"
-
 export * from "./continuity/prepare-to-sync-realtime-continuity"
 export * from "./ipc-sockets"
 export * from "./realtime-action-receiver"
@@ -10,20 +7,5 @@ export * from "./realtime-mutable-provider"
 export * from "./realtime-server-stores"
 export * from "./realtime-state-provider"
 export * from "./realtime-state-receiver"
-
-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
-}
-export type ServerConfig = {
-	socket: Socket
-	store?: RootStore
-}
+export type * from "./server-config"
+export type * from "./socket-interface"

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

@@ -1,16 +1,26 @@
-import type { ChildProcessWithoutNullStreams } from "node:child_process"
+import type { Readable, Writable } from "node:stream"
 
-import type { Json } from "atom.io/json"
+import type { Json, stringified } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 
-import type { EventBuffer, Events } from "./custom-socket"
+import type { EventBuffer, EventPayload, Events } from "./custom-socket"
 import { CustomSocket } from "./custom-socket"
 
 /* eslint-disable no-console */
 
+export type ChildProcess = {
+	pid?: number | undefined
+	stdin: Writable
+	stdout: Readable
+	stderr: Readable
+}
+
+export type StderrLog = [`e` | `i` | `w`, ...Json.Array]
+
 export class ChildSocket<
 	I extends Events,
 	O extends Events,
+	P extends ChildProcess = ChildProcess,
 > extends CustomSocket<I, O> {
 	protected incompleteData = ``
 	protected unprocessedEvents: string[] = []
@@ -19,13 +29,13 @@ export class ChildSocket<
 
 	public id = `#####`
 
-	public process: ChildProcessWithoutNullStreams
+	public proc: P
 	public key: string
 	public logger: Pick<Console, `error` | `info` | `warn`>
 
-	protected handleLog(arg: Json.Serializable): void {
-		if (Array.isArray(arg)) {
-			const [level, ...rest] = arg
+	protected handleLog(log: StderrLog): void {
+		if (Array.isArray(log)) {
+			const [level, ...rest] = log
 			switch (level) {
 				case `i`:
 					this.logger.info(...rest)
@@ -36,14 +46,12 @@ export class ChildSocket<
 				case `e`:
 					this.logger.error(...rest)
 					break
-				default:
-					return
 			}
 		}
 	}
 
 	public constructor(
-		process: ChildProcessWithoutNullStreams,
+		proc: P,
 		key: string,
 		logger?: Pick<Console, `error` | `info` | `warn`>,
 	) {
@@ -51,17 +59,17 @@ export class ChildSocket<
 			const stringifiedEvent = JSON.stringify([event, ...args]) + `\x03`
 			const errorHandler = (err: { code: string }) => {
 				if (err.code === `EPIPE`) {
-					console.error(`EPIPE error during write`, this.process.stdin)
+					console.error(`EPIPE error during write`, this.proc.stdin)
 				}
-				this.process.stdin.removeListener(`error`, errorHandler)
+				this.proc.stdin.removeListener(`error`, errorHandler)
 			}
 
-			this.process.stdin.once(`error`, errorHandler)
-			this.process.stdin.write(stringifiedEvent)
+			this.proc.stdin.once(`error`, errorHandler)
+			this.proc.stdin.write(stringifiedEvent)
 
 			return this
 		})
-		this.process = process
+		this.proc = proc
 		this.key = key
 		this.logger = logger ?? {
 			info: (...args: unknown[]) => {
@@ -74,74 +82,125 @@ export class ChildSocket<
 				console.error(this.id, this.key, ...args)
 			},
 		}
-		this.process.stdout.on(
+		this.proc.stdout.on(
 			`data`,
-			<Event extends keyof I>(buffer: EventBuffer<string, I[Event]>) => {
+			<K extends string & keyof I>(buffer: EventBuffer<I, K>) => {
 				const chunk = buffer.toString()
 
 				if (chunk === `ALIVE`) {
-					// console.log(chunk)
+					this.logger.info(chunk)
 					return
 				}
-				this.unprocessedEvents.push(...chunk.split(`\x03`))
-				// console.log(`🤓`, chunk.length)
-				// console.log(`🤓`, this.unprocessedEvents.length)
-				// console.log(`🤓`, ...this.unprocessedEvents.map((x) => x.length))
-				const newInput = this.unprocessedEvents.shift()
-				this.incompleteData += newInput ?? ``
-				try {
-					if (this.incompleteData.startsWith(`error`)) {
-						console.log(`❗`, this.incompleteData)
+
+				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
 					}
-					let parsedEvent = parseJson(this.incompleteData)
-					this.handleEvent(...(parsedEvent 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
+					try {
+						const jsonPiece = parseJson(piece as stringified<EventPayload<I, K>>)
+						this.handleEvent(...jsonPiece)
+						this.incompleteData = ``
+					} catch (thrown0) {
+						if (thrown0 instanceof Error) {
+							console.error(
+								[
+									`❌ Malformed data received from child process`,
+									``,
+									piece,
+									``,
+									thrown0.message,
+								].join(`\n❌\t`),
+							)
+						}
+						try {
+							if (idx === 0) {
+								this.incompleteData = piece
+								const maybeActualJsonPiece = parseJson(
+									initialMaybeWellFormed as stringified<EventPayload<I, K>>,
+								)
+								this.handleEvent(...maybeActualJsonPiece)
+								this.incompleteData = ``
+							} else {
+								this.incompleteData += piece
+							}
+						} catch (thrown1) {
+							if (thrown1 instanceof Error) {
+								console.error(
+									[
+										`❌ Malformed data received from child process`,
+										``,
+										initialMaybeWellFormed,
+										``,
+										thrown1.message,
+									].join(`\n❌\t`),
+								)
 							}
-							parsedEvent = parseJson(event)
-							this.handleEvent(...(parsedEvent as [string, ...I[keyof I]]))
 						}
 					}
-					this.incompleteData = ``
-				} catch (error) {
-					console.warn(`⚠️----------------⚠️`)
-					console.warn(this.incompleteData)
-					console.warn(`⚠️----------------⚠️`)
-					console.error(error)
+					++idx
 				}
 			},
 		)
-		this.process.stderr.on(`data`, (buf) => {
-			const chunk = buf.toString()
-			this.unprocessedLogs.push(...chunk.split(`\x03`))
-			// console.log(`🤫`, chunk.length)
-			// console.log(`🤫`, this.unprocessedLogs.length)
-			// console.log(`🤫`, ...this.unprocessedLogs.map((x) => x.length))
-			const newInput = this.unprocessedLogs.shift()
-			this.incompleteLog += newInput ?? ``
-			try {
-				let parsedLog = parseJson(this.incompleteLog)
-				// console.log(`🤫`, parsedLog)
-				this.handleLog(parsedLog)
-				while (this.unprocessedLogs.length > 0) {
-					this.incompleteLog = this.unprocessedLogs.shift() ?? ``
-					if (this.incompleteLog) {
-						parsedLog = parseJson(this.incompleteLog)
-						this.handleLog(parsedLog)
+		this.proc.stderr.on(`data`, (buffer: Buffer) => {
+			const chunk = buffer.toString()
+			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 as stringified<StderrLog>)
+					this.handleLog(jsonPiece)
+					this.incompleteData = ``
+				} catch (thrown0) {
+					if (thrown0 instanceof Error) {
+						console.error(
+							[
+								`❌ Malformed log received from child process`,
+								``,
+								piece,
+								``,
+								thrown0.message,
+							].join(`\n❌\t`),
+						)
+					}
+					try {
+						if (idx === 0) {
+							this.incompleteData = piece
+							const maybeActualJsonPiece = parseJson(
+								initialMaybeWellFormed as stringified<StderrLog>,
+							)
+							this.handleLog(maybeActualJsonPiece)
+							this.incompleteData = ``
+						} else {
+							this.incompleteData += piece
+						}
+					} catch (thrown1) {
+						if (thrown1 instanceof Error) {
+							console.error(
+								[
+									`❌ Malformed log received from child process...`,
+									``,
+									initialMaybeWellFormed,
+									``,
+									thrown1.message,
+								].join(`\n❌\t`),
+							)
+						}
 					}
 				}
-			} catch (error) {
-				console.error(`❌❌❌`)
-				console.error(this.incompleteLog)
-				console.error(error)
-				console.error(`❌❌❌️`)
+				++idx
 			}
 		})
-		if (process.pid) {
-			this.id = process.pid.toString()
+		if (proc.pid) {
+			this.id = proc.pid.toString()
 		}
 	}
 }

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

@@ -1,35 +1,37 @@
 import type { Json, stringified } from "atom.io/json"
 
-import type { Socket } from ".."
+import type { Socket } from "../socket-interface"
 
 export type Events = Json.Object<string, Json.Serializable[]>
 
-export type StringifiedEvent<
-	Key extends string,
-	Params extends Json.Serializable[],
-> = stringified<[Key, ...Params]>
+export type EventPayload<
+	E extends Events,
+	K extends string & keyof E = string & keyof E,
+> = [string, ...E[K]]
 
 export interface EventBuffer<
-	Key extends string,
-	Params extends Json.Serializable[],
+	E extends Events,
+	K extends string & keyof E = string & keyof E,
 > extends Buffer {
-	toString(): StringifiedEvent<Key, Params>
+	toString(): stringified<EventPayload<E, K>>
 }
 
-export class CustomSocket<I extends Events, O extends Events> implements Socket {
+export abstract class CustomSocket<I extends Events, O extends Events>
+	implements Socket
+{
 	protected listeners: Map<keyof O, Set<(...args: Json.Array) => void>>
 	protected globalListeners: Set<(event: string, ...args: Json.Array) => void>
-	protected handleEvent<Event extends keyof I>(
-		event: string,
-		...args: I[Event]
+	protected handleEvent<K extends string & keyof I>(
+		...args: EventPayload<I, K>
 	): void {
+		const [event, ...rest] = args
 		for (const listener of this.globalListeners) {
-			listener(event, ...args)
+			listener(event, ...rest)
 		}
 		const listeners = this.listeners.get(event)
 		if (listeners) {
 			for (const listener of listeners) {
-				listener(...args)
+				listener(...rest)
 			}
 		}
 	}