atom.io 0.40.6 → 0.40.8

package/src/realtime-server/continuity/receive-action-requests.ts

@@ -0,0 +1,68 @@
+import type { TransactionOutcomeEvent, TransactionToken } from "atom.io"
+import type { Store } from "atom.io/internal"
+import { actUponStore } from "atom.io/internal"
+import type { Json, JsonIO } from "atom.io/json"
+import type { ContinuityToken } from "atom.io/realtime"
+
+import { employSocket } from "../employ-socket"
+import type { Socket } from "../socket-interface"
+
+export function receiveActionRequests(
+	store: Store,
+	socket: Socket,
+	continuity: ContinuityToken,
+	userKey: string,
+): () => void {
+	const continuityKey = continuity.key
+
+	return employSocket(
+		socket,
+		`tx-run:${continuityKey}`,
+		function serveTransactionRequest(
+			txOutcome: Json.Serializable &
+				Pick<
+					TransactionOutcomeEvent<TransactionToken<JsonIO>>,
+					`id` | `params` | `token`
+				>,
+		) {
+			store.logger.info(`🛎️`, `continuity`, continuityKey, `received`, txOutcome)
+			const transactionKey = txOutcome.token.key
+			const updateId = txOutcome.id
+			const performanceKey = `tx-run:${transactionKey}:${updateId}`
+			const performanceKeyStart = `${performanceKey}:start`
+			const performanceKeyEnd = `${performanceKey}:end`
+			performance.mark(performanceKeyStart)
+			try {
+				actUponStore(
+					store,
+					{ type: `transaction`, key: transactionKey },
+					updateId,
+				)(...txOutcome.params)
+			} catch (thrown) {
+				if (thrown instanceof Error) {
+					store.logger.error(
+						`❌`,
+						`continuity`,
+						continuityKey,
+						`failed to run transaction ${transactionKey} from ${userKey} with update ${updateId}`,
+						thrown.message,
+					)
+				}
+			}
+			performance.mark(performanceKeyEnd)
+			const metric = performance.measure(
+				performanceKey,
+				performanceKeyStart,
+				performanceKeyEnd,
+			)
+			store.logger.info(
+				`🚀`,
+				`transaction`,
+				transactionKey,
+				updateId,
+				userKey,
+				metric.duration,
+			)
+		},
+	)
+}

package/src/realtime-server/continuity/track-acknowledgements.ts

@@ -0,0 +1,46 @@
+import type { Store } from "atom.io/internal"
+import { getFromStore, setIntoStore } from "atom.io/internal"
+import type { ContinuityToken } from "atom.io/realtime"
+
+import { employSocket } from "../employ-socket"
+import type { UserKey } from "../realtime-server-stores"
+import type { Socket } from "../socket-interface"
+import { unacknowledgedUpdatesAtoms } from "./continuity-store"
+
+export function trackAcknowledgements(
+	store: Store,
+	socket: Socket,
+	continuity: ContinuityToken,
+	userKey: UserKey,
+): () => void {
+	const continuityKey = continuity.key
+	const userUnacknowledgedUpdates = getFromStore(
+		store,
+		unacknowledgedUpdatesAtoms,
+		userKey,
+	)
+	function trackClientAcknowledgement(epoch: number): void {
+		store.logger.info(
+			`👍`,
+			`continuity`,
+			continuityKey,
+			`${userKey} acknowledged epoch ${epoch}`,
+		)
+		const isUnacknowledged = userUnacknowledgedUpdates[0]?.epoch === epoch
+		if (isUnacknowledged) {
+			setIntoStore(store, unacknowledgedUpdatesAtoms, userKey, (updates) => {
+				updates.shift()
+				store.logger.info(
+					`👍`,
+					`continuity`,
+					continuityKey,
+					`${userKey} unacknowledged update queue now has`,
+					updates.length,
+					`items`,
+				)
+				return updates
+			})
+		}
+	}
+	return employSocket(socket, `ack:${continuityKey}`, trackClientAcknowledgement)
+}

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,29 +1,10 @@
-import type { RootStore } from "atom.io/internal"
-import type { Json } from "atom.io/json"
-
-export * from "./continuity/prepare-to-sync-realtime-continuity"
+export * from "./continuity/provide-continuity"
 export * from "./ipc-sockets"
-export * from "./realtime-action-receiver"
 export * from "./realtime-family-provider"
 export * from "./realtime-mutable-family-provider"
 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<
+	receiveRelay extends Events,
+	K extends string & keyof receiveRelay = string & keyof receiveRelay,
+> = [string, ...receiveRelay[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)
 			}
 		}
 	}