atom.io 0.18.0 → 0.18.1

package/realtime-client/src/sync-server-action.ts

@@ -1,168 +0,0 @@
-import type * as AtomIO from "atom.io"
-import * as Internal from "atom.io/internal"
-import type { Socket } from "socket.io-client"
-
-import {
-	confirmedUpdateQueue,
-	optimisticUpdateQueue,
-} from "./realtime-client-stores"
-
-export function syncAction<ƒ extends AtomIO.ƒn>(
-	token: AtomIO.TransactionToken<ƒ>,
-	socket: Socket,
-	store: Internal.Store,
-): () => void {
-	Internal.assignTransactionToContinuity(`default`, token.key, store)
-
-	const optimisticQueue = Internal.getFromStore(optimisticUpdateQueue, store)
-	const confirmedQueue = Internal.getFromStore(confirmedUpdateQueue, store)
-
-	const unsubscribeFromLocalUpdates = Internal.subscribeToTransaction(
-		token,
-		(clientUpdate) => {
-			const optimisticUpdateQueueIndex = optimisticQueue.findIndex(
-				(update) => update.id === clientUpdate.id,
-			)
-			if (optimisticUpdateQueueIndex === -1) {
-				Internal.setIntoStore(
-					optimisticUpdateQueue,
-					(queue) => {
-						queue.push(clientUpdate)
-						queue.sort((a, b) => a.epoch - b.epoch)
-						return queue
-					},
-					store,
-				)
-			} else {
-				Internal.setIntoStore(
-					optimisticUpdateQueue,
-					(queue) => {
-						queue[optimisticUpdateQueueIndex] = clientUpdate
-						return queue
-					},
-					store,
-				)
-			}
-			socket.emit(`tx-run:${token.key}`, clientUpdate)
-		},
-		`tx-run:${token.key}`,
-		store,
-	)
-	const reconcileUpdates = (
-		optimisticUpdate: AtomIO.TransactionUpdate<ƒ>,
-		confirmedUpdate: AtomIO.TransactionUpdate<ƒ>,
-	) => {
-		Internal.setIntoStore(
-			optimisticUpdateQueue,
-			(queue) => {
-				queue.shift()
-				return queue
-			},
-			store,
-		)
-		if (optimisticUpdate.id === confirmedUpdate.id) {
-			const clientResult = JSON.stringify(optimisticUpdate.updates)
-			const serverResult = JSON.stringify(confirmedUpdate.updates)
-			if (clientResult === serverResult) {
-				store.logger.info(
-					`✅`,
-					`transaction`,
-					token.key,
-					`results for ${optimisticUpdate.id} match between client and server`,
-				)
-				socket.emit(`tx-ack:${token.key}`, confirmedUpdate.epoch)
-				return
-			}
-		} else {
-			// id mismatch
-			store.logger.info(
-				`❌`,
-				`transaction`,
-				token.key,
-				`${store.config.name} thought update #${confirmedUpdate.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate.key}:${confirmedUpdate.id}`,
-			)
-		}
-		for (const subsequentOptimistic of optimisticQueue.toReversed()) {
-			Internal.ingestTransactionUpdate(`oldValue`, subsequentOptimistic, store)
-		}
-		Internal.ingestTransactionUpdate(`oldValue`, optimisticUpdate, store)
-		Internal.ingestTransactionUpdate(`newValue`, confirmedUpdate, store)
-		socket.emit(`tx-ack:${token.key}`, confirmedUpdate.epoch)
-		for (const subsequentOptimistic of optimisticQueue) {
-			const token = Object.assign(
-				{ type: `transaction` } as const,
-				subsequentOptimistic,
-			)
-			const { id, params } = subsequentOptimistic
-			Internal.actUponStore(token, id, store)(...params)
-		}
-	}
-
-	const registerAndAttemptConfirmedUpdate = (
-		confirmedUpdate: AtomIO.TransactionUpdate<ƒ>,
-	) => {
-		const zerothOptimisticUpdate = optimisticQueue[0]
-		if (zerothOptimisticUpdate) {
-			if (zerothOptimisticUpdate.epoch === confirmedUpdate.epoch) {
-				reconcileUpdates(zerothOptimisticUpdate, confirmedUpdate)
-				for (const nextConfirmed of confirmedQueue) {
-					const nextOptimistic = optimisticQueue[0]
-					if (nextConfirmed.epoch === nextOptimistic.epoch) {
-						reconcileUpdates(nextOptimistic, nextConfirmed)
-					} else {
-						break
-					}
-				}
-			} else {
-				// epoch mismatch
-
-				const hasEnqueuedOptimisticUpdate = optimisticQueue.some(
-					(update) => update.epoch === confirmedUpdate.epoch,
-				)
-				if (hasEnqueuedOptimisticUpdate) {
-					Internal.setIntoStore(
-						confirmedUpdateQueue,
-						(queue) => {
-							queue.push(confirmedUpdate)
-							queue.sort((a, b) => a.epoch - b.epoch)
-							return queue
-						},
-						store,
-					)
-				}
-			}
-		} else {
-			const continuityEpoch = Internal.getEpochNumberOfAction(token.key, store)
-			if (
-				Internal.isRootStore(store) &&
-				continuityEpoch === confirmedUpdate.epoch - 1
-			) {
-				Internal.ingestTransactionUpdate(`newValue`, confirmedUpdate, store)
-				socket.emit(`tx-ack:${token.key}`, confirmedUpdate.epoch)
-				Internal.setEpochNumberOfAction(token.key, confirmedUpdate.epoch, store)
-			} else if (Internal.isRootStore(store)) {
-				store.logger.info(
-					`❌`,
-					`transaction`,
-					token.key,
-					`received out-of-order update from server`,
-					{
-						clientEpoch: store.transactionMeta.epoch,
-						serverEpoch: confirmedUpdate.epoch,
-					},
-				)
-			}
-		}
-	}
-	socket.off(`tx-new:${token.key}`, registerAndAttemptConfirmedUpdate)
-	socket.on(`tx-new:${token.key}`, registerAndAttemptConfirmedUpdate)
-	socket.emit(`tx-sub:${token.key}`)
-	const unsubscribeFromIncomingUpdates = () => {
-		socket.off(`tx-new:${token.key}`, registerAndAttemptConfirmedUpdate)
-		socket.emit(`tx-unsub:${token.key}`)
-	}
-	return () => {
-		unsubscribeFromLocalUpdates()
-		unsubscribeFromIncomingUpdates()
-	}
-}

package/realtime-client/src/sync-state.ts

@@ -1,19 +0,0 @@
-import type * as AtomIO from "atom.io"
-import { type Store, setIntoStore } from "atom.io/internal"
-import type { Json } from "atom.io/json"
-import type { Socket } from "socket.io-client"
-
-export function syncState<J extends Json.Serializable>(
-	token: AtomIO.WritableToken<J>,
-	socket: Socket,
-	store: Store,
-): () => void {
-	const setServedValue = (data: J) => {
-		setIntoStore(token, data, store)
-	}
-	socket.on(`value:${token.key}`, setServedValue)
-	socket.emit(`get:${token.key}`)
-	return () => {
-		socket.off(`value:${token.key}`, setServedValue)
-	}
-}

package/realtime-react/src/use-sync-server-action.ts

@@ -1,17 +0,0 @@
-import type * as AtomIO from "atom.io"
-import { actUponStore, arbitrary } from "atom.io/internal"
-import { StoreContext } from "atom.io/react"
-import * as RTC from "atom.io/realtime-client"
-import * as React from "react"
-
-import { useRealtimeService } from "./use-realtime-service"
-
-export function useSyncAction<ƒ extends AtomIO.ƒn>(
-	token: AtomIO.TransactionToken<ƒ>,
-): (...parameters: Parameters<ƒ>) => ReturnType<ƒ> {
-	const store = React.useContext(StoreContext)
-	useRealtimeService(`tx-sync:${token.key}`, (socket) => {
-		return RTC.syncAction(token, socket, store)
-	})
-	return actUponStore(token, arbitrary(), store)
-}

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

@@ -1,17 +0,0 @@
-import type * as AtomIO from "atom.io"
-import type { Json } from "atom.io/json"
-import { StoreContext, useO } from "atom.io/react"
-import * as RTC from "atom.io/realtime-client"
-import * as React from "react"
-
-import { useRealtimeService } from "./use-realtime-service"
-
-export function useSync<J extends Json.Serializable>(
-	token: AtomIO.WritableToken<J>,
-): J {
-	const store = React.useContext(StoreContext)
-	useRealtimeService(`sync:${token.key}`, (socket) =>
-		RTC.syncState(token, socket, store),
-	)
-	return useO(token)
-}

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

@@ -1,230 +0,0 @@
-import type { ChildProcessWithoutNullStreams } from "child_process"
-
-import { Subject } from "atom.io/internal"
-import { parseJson } from "atom.io/json"
-import type { Json, Stringified } from "atom.io/json"
-
-import type { Socket } from "."
-
-export type Events = Json.Object<string, Json.Serializable[]>
-
-export type StringifiedEvent<
-	Key extends string,
-	Params extends Json.Serializable[],
-> = Stringified<[Key, ...Params]>
-
-export interface EventBuffer<
-	Key extends string,
-	Params extends Json.Serializable[],
-> extends Buffer {
-	toString(): StringifiedEvent<Key, Params>
-}
-
-export class CustomSocket<I extends Events, O extends Events> implements Socket {
-	protected listeners: Map<keyof I, 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]
-	): void {
-		for (const listener of this.globalListeners) {
-			listener(event, ...args)
-		}
-		const listeners = this.listeners.get(event)
-		if (listeners) {
-			for (const listener of listeners) {
-				listener(...args)
-			}
-		}
-	}
-
-	public id = `no_id_retrieved`
-
-	public constructor(
-		public emit: <Event extends keyof O>(
-			event: Event,
-			...args: O[Event]
-		) => CustomSocket<I, O>,
-	) {
-		this.listeners = new Map()
-		this.globalListeners = new Set()
-	}
-
-	public on<Event extends keyof I>(
-		event: Event,
-		listener: (...args: I[Event]) => void,
-	): CustomSocket<I, O> {
-		const listeners = this.listeners.get(event)
-		if (listeners) {
-			listeners.add(listener)
-		} else {
-			this.listeners.set(event, new Set([listener]))
-		}
-		return this
-	}
-
-	public onAny(
-		listener: (event: string, ...args: Json.Array) => void,
-	): CustomSocket<I, O> {
-		this.globalListeners.add(listener)
-		return this
-	}
-
-	public off<Event extends keyof I>(
-		event: Event,
-		listener: (...args: I[Event]) => void,
-	): CustomSocket<I, O> {
-		const listeners = this.listeners.get(event)
-		if (listeners) {
-			listeners.delete(listener)
-		}
-		return this
-	}
-
-	public offAny(
-		listener: (event: string, ...args: Json.Array) => void,
-	): CustomSocket<I, O> {
-		this.globalListeners.delete(listener)
-		return this
-	}
-}
-
-export class ChildSocket<
-	I extends Events,
-	O extends Events & {
-		/* eslint-disable quotes */
-		"setup-relay": [string]
-		/* eslint-enable quotes */
-	},
-> extends CustomSocket<I, O> {
-	protected process: ChildProcessWithoutNullStreams
-
-	public id = `no_id_retrieved`
-
-	public constructor(process: ChildProcessWithoutNullStreams) {
-		super((event, ...args) => {
-			const stringifiedEvent = JSON.stringify([event, ...args]) + `\n`
-			this.process.stdin.write(stringifiedEvent)
-			return this
-		})
-		this.process = process
-		this.process.stdout.on(
-			`data`,
-			<Event extends keyof I>(buffer: EventBuffer<string, I[Event]>) => {
-				const stringifiedEvent = buffer.toString()
-				const parsedEvent = parseJson(stringifiedEvent)
-				this.handleEvent(...parsedEvent)
-			},
-		)
-		if (process.pid) {
-			this.id = process.pid.toString()
-		}
-	}
-}
-
-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 id = `no_id_retrieved`
-
-	public constructor(id: string) {
-		super((...args) => {
-			this.out.next(args as any)
-			return this
-		})
-		this.id = id
-		this.in = new Subject()
-		this.out = new Subject()
-		this.in.subscribe(`socket`, (event) => {
-			this.handleEvent(...(event as [string, ...I[keyof I]]))
-		})
-	}
-}
-
-export class ParentSocket<
-	I extends Events & {
-		[id in string as `relay:${id}`]: [string, ...Json.Serializable[]]
-	} & {
-		/* eslint-disable quotes */
-		"setup-relay": [string]
-		/* eslint-enable quotes */
-	},
-	O extends Events & {
-		[id in string as `relay:${id}`]: [string, ...Json.Serializable[]]
-	},
-> extends CustomSocket<I, O> {
-	protected queue: string[]
-	protected relays: Map<string, SubjectSocket<any, any>>
-	protected relayServices: ((
-		socket: SubjectSocket<any, any>,
-	) => (() => void) | void)[]
-	protected process: NodeJS.Process
-
-	public id = `no_id_retrieved`
-
-	public constructor() {
-		super((event, ...args) => {
-			const stringifiedEvent = JSON.stringify([event, ...args])
-			this.process.stdout.write(stringifiedEvent)
-			return this
-		})
-		this.process = process
-		this.process.stdin.resume()
-		this.queue = []
-		this.relays = new Map()
-		this.relayServices = []
-
-		this.process.stdin.on(
-			`data`,
-			<Event extends keyof I>(chunk: EventBuffer<string, I[Event]>) => {
-				const buffer = chunk.toString()
-				this.queue.push(...buffer.split(`\n`))
-
-				while (this.queue.length > 0) {
-					try {
-						const event = this.queue.shift() as StringifiedEvent<any, any>
-						if (event === ``) continue
-						const parsedEvent = parseJson(event)
-						this.handleEvent(...(parsedEvent as [string, ...I[keyof I]]))
-					} catch (error) {
-						this.process.stderr.write(`❌ ${error}\n`)
-						break
-					}
-				}
-			},
-		)
-
-		// process.stdin.on(`end`, () => process.exit(0))
-		process.on(`SIGINT`, () => process.exit(0))
-		if (process.pid) {
-			this.id = process.pid?.toString()
-		}
-
-		this.on(`setup-relay`, (id: string) => {
-			const relay = new SubjectSocket(`relay:${id}`)
-			this.relays.set(id, relay)
-			for (const attachServices of this.relayServices) {
-				attachServices(relay)
-			}
-			this.on(`relay:${id}`, (...data) => {
-				relay.in.next(data)
-			})
-			relay.out.subscribe(`socket`, (data) => {
-				this.emit(...(data as [string, ...O[keyof O]]))
-			})
-		})
-	}
-
-	public relay(
-		attachServices: (socket: SubjectSocket<any, any>) => (() => void) | void,
-	): void {
-		this.relayServices.push(attachServices)
-		const relays = this.relays.values()
-		for (const relay of relays) {
-			attachServices(relay)
-		}
-	}
-}

package/realtime-server/src/realtime-action-synchronizer.ts

@@ -1,164 +0,0 @@
-import type * as AtomIO from "atom.io"
-import {
-	IMPLICIT,
-	actUponStore,
-	assignTransactionToContinuity,
-	findInStore,
-	getFromStore,
-	setIntoStore,
-	subscribeToTransaction,
-} from "atom.io/internal"
-import type { Json, JsonIO } from "atom.io/json"
-
-import type { ServerConfig } from "."
-import {
-	completeUpdateAtoms,
-	redactedUpdateSelectors,
-	transactionRedactorAtoms,
-	userUnacknowledgedQueues,
-	usersOfSockets,
-} from "./realtime-server-stores"
-
-export type ActionSynchronizer = ReturnType<typeof realtimeActionSynchronizer>
-export function realtimeActionSynchronizer({
-	socket,
-	store = IMPLICIT.STORE,
-}: ServerConfig) {
-	return function actionSynchronizer<ƒ extends JsonIO>(
-		tx: AtomIO.TransactionToken<ƒ>,
-		filter?: (
-			update: AtomIO.TransactionUpdateContent[],
-		) => AtomIO.TransactionUpdateContent[],
-	): () => void {
-		assignTransactionToContinuity(`default`, tx.key, store)
-
-		const userKeyState = findInStore(
-			usersOfSockets.states.userKeyOfSocket,
-			socket.id,
-			store,
-		)
-		const userKey = getFromStore(userKeyState, store)
-		if (!userKey) {
-			store.logger.error(
-				`❌`,
-				`transaction`,
-				tx.key,
-				`Tried to create a synchronizer for a socket (${socket.id}) that is not connected to a user.`,
-			)
-			return () => {}
-		}
-		const userUnacknowledgedQueue = findInStore(
-			userUnacknowledgedQueues,
-			userKey,
-			store,
-		)
-		const userUnacknowledgedUpdates = getFromStore(
-			userUnacknowledgedQueue,
-			store,
-		)
-		if (filter) {
-			const redactorState = findInStore(transactionRedactorAtoms, tx.key, store)
-			setIntoStore(redactorState, { filter }, store)
-		}
-
-		const fillTransactionRequest = (
-			update: Pick<AtomIO.TransactionUpdate<ƒ>, `id` | `params`>,
-		) => {
-			const performanceKey = `tx-run:${tx.key}:${update.id}`
-			const performanceKeyStart = `${performanceKey}:start`
-			const performanceKeyEnd = `${performanceKey}:end`
-			performance.mark(performanceKeyStart)
-			actUponStore<ƒ>(tx, update.id, store)(...update.params)
-			performance.mark(performanceKeyEnd)
-			const metric = performance.measure(
-				performanceKey,
-				performanceKeyStart,
-				performanceKeyEnd,
-			)
-			store?.logger.info(`🚀`, `transaction`, tx.key, update.id, metric.duration)
-		}
-		socket.off(`tx-run:${tx.key}`, fillTransactionRequest)
-		socket.on(`tx-run:${tx.key}`, fillTransactionRequest)
-
-		let unsubscribeFromTransaction: (() => void) | undefined
-		const fillTransactionSubscriptionRequest = () => {
-			unsubscribeFromTransaction = subscribeToTransaction(
-				tx,
-				(update) => {
-					const updateState = findInStore(completeUpdateAtoms, update.id, store)
-					setIntoStore(updateState, update, store)
-					const toEmit: Pick<
-						AtomIO.TransactionUpdate<ƒ>,
-						`epoch` | `id` | `key` | `output` | `updates`
-					> | null = filter
-						? getFromStore(
-								findInStore(redactedUpdateSelectors, [tx.key, update.id], store),
-								store,
-						  )
-						: update
-
-					// the problem is that only while a socket is connected can
-					// updates be set in the queue for that socket's client.
-					//
-					// we need a client session that can persist between disconnects
-					setIntoStore(
-						userUnacknowledgedQueue,
-						(updates) => {
-							if (toEmit) {
-								updates.push(toEmit)
-								updates.sort((a, b) => a.epoch - b.epoch)
-							}
-							return updates
-						},
-						store,
-					)
-
-					socket.emit(`tx-new:${tx.key}`, toEmit as Json.Serializable)
-				},
-				`tx-sub:${tx.key}:${socket.id}`,
-				store,
-			)
-			socket.on(`tx-unsub:${tx.key}`, unsubscribeFromTransaction)
-		}
-		socket.on(`tx-sub:${tx.key}`, fillTransactionSubscriptionRequest)
-
-		let i = 1
-		let next = 1
-		const retry = setInterval(() => {
-			const toEmit = userUnacknowledgedUpdates[0]
-			if (toEmit && i === next) {
-				socket.emit(`tx-new:${tx.key}`, toEmit as Json.Serializable)
-				next *= 2
-			}
-
-			i++
-		}, 250)
-
-		const trackClientAcknowledgement = (epoch: number) => {
-			i = 1
-			next = 1
-			8
-			if (userUnacknowledgedUpdates[0]?.epoch === epoch) {
-				setIntoStore(
-					userUnacknowledgedQueue,
-					(updates) => {
-						updates.shift()
-						return updates
-					},
-					store,
-				)
-			}
-		}
-		socket.on(`tx-ack:${tx.key}`, trackClientAcknowledgement)
-
-		return () => {
-			if (unsubscribeFromTransaction) {
-				unsubscribeFromTransaction()
-				unsubscribeFromTransaction = undefined
-			}
-			clearInterval(retry)
-			socket.off(`tx-run:${tx.key}`, fillTransactionRequest)
-			socket.off(`tx-sub:${tx.key}`, fillTransactionSubscriptionRequest)
-		}
-	}
-}

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

@@ -1,97 +0,0 @@
-import type { ChildProcessWithoutNullStreams } from "child_process"
-import { spawn } from "child_process"
-
-import * as AtomIO from "atom.io"
-import type { Loadable } from "atom.io/data"
-import { join } from "atom.io/data"
-import { SetRTX } from "atom.io/transceivers/set-rtx"
-
-export type RoomArguments =
-	| [script: string, options: string[]]
-	| [script: string]
-
-export const roomIndex = AtomIO.atom({
-	key: `roomIndex`,
-	default: () => new SetRTX<string>(),
-	mutable: true,
-	toJson: (set) => set.toJSON(),
-	fromJson: (json) => SetRTX.fromJSON(json),
-})
-
-export type UserInRoomMeta = {
-	enteredAtEpoch: number
-}
-export const DEFAULT_USER_IN_ROOM_META: UserInRoomMeta = {
-	enteredAtEpoch: 0,
-}
-export const usersInRooms = join(
-	{
-		key: `usersInRooms`,
-		between: [`room`, `user`],
-		cardinality: `1:n`,
-	},
-	DEFAULT_USER_IN_ROOM_META,
-)
-
-export const roomArgumentsAtoms = AtomIO.atomFamily<RoomArguments, string>({
-	key: `roomArguments`,
-	default: [`echo Hello World!`],
-})
-
-export const roomSelectors = AtomIO.selectorFamily<
-	Loadable<ChildProcessWithoutNullStreams>,
-	string
->({
-	key: `room`,
-	get:
-		(roomId) =>
-		({ get, find }) => {
-			const argumentsState = find(roomArgumentsAtoms, roomId)
-			const args = get(argumentsState)
-			const [script, options] = args
-			return new Promise((resolve) => {
-				const room = spawn(script, options, { env: process.env })
-				const resolver = (data: Buffer) => {
-					if (data.toString() === `✨`) {
-						room.stdout.off(`data`, resolver)
-						resolve(room)
-					}
-				}
-				room.stdout.on(`data`, resolver)
-			})
-		},
-})
-
-export const createRoomTX = AtomIO.transaction<
-	(
-		roomId: string,
-		script: string,
-		options?: string[],
-	) => Loadable<ChildProcessWithoutNullStreams>
->({
-	key: `createRoom`,
-	do: ({ get, set, find }, roomId, script, options) => {
-		const args: RoomArguments = options ? [script, options] : [script]
-		const roomArgumentsState = find(roomArgumentsAtoms, roomId)
-		set(roomArgumentsState, args)
-		set(roomIndex, (s) => s.add(roomId))
-		const roomState = find(roomSelectors, roomId)
-		const room = get(roomState)
-		return room
-	},
-})
-export type CreateRoomIO = AtomIO.TransactionIO<typeof createRoomTX>
-
-export const joinRoomTX = AtomIO.transaction<
-	(roomId: string, userId: string, enteredAtEpoch: number) => UserInRoomMeta
->({
-	key: `joinRoom`,
-	do: (transactors, roomId, userId, enteredAtEpoch) => {
-		const meta = { enteredAtEpoch }
-		usersInRooms.transact(transactors, ({ relations }) => {
-			relations.set(roomId, userId, meta)
-		})
-		return meta
-	},
-})
-export type JoinRoomIO = AtomIO.TransactionIO<typeof joinRoomTX>