atom.io 0.40.6 → 0.40.8

package/src/realtime-react/on-mount.ts

@@ -1,5 +0,0 @@
-import { useSingleEffect } from "./use-single-effect"
-
-export function onMount(effect: () => (() => void) | undefined | void): void {
-	useSingleEffect(effect, [])
-}

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

@@ -1,19 +0,0 @@
-import type * as AtomIO from "atom.io"
-import type { Fn } from "atom.io/internal"
-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 useServerAction<F extends Fn>(
-	token: AtomIO.TransactionToken<F>,
-): (...parameters: Parameters<F>) => ReturnType<F> {
-	const store = React.useContext(StoreContext)
-
-	useRealtimeService(`tx:${token.key}`, (socket) =>
-		RTC.serverAction(store, socket, token),
-	)
-	return actUponStore(store, token, arbitrary())
-}

package/src/realtime-server/continuity/prepare-to-serve-transaction-request.ts

@@ -1,59 +0,0 @@
-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"
-
-export function prepareToServeTransactionRequest(
-	store: Store,
-	continuity: ContinuityToken,
-	userKey: string,
-): (
-	event: Json.Serializable &
-		Pick<
-			TransactionOutcomeEvent<TransactionToken<JsonIO>>,
-			`id` | `params` | `token`
-		>,
-) => void {
-	const continuityKey = continuity.key
-	return function serveTransactionRequest(txOutcome) {
-		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/prepare-to-sync-realtime-continuity.ts

@@ -1,145 +0,0 @@
-import {
-	findInStore,
-	findRelationsInStore,
-	getFromStore,
-	IMPLICIT,
-	subscribeToState,
-} from "atom.io/internal"
-import type { Json } from "atom.io/json"
-import type { ContinuityToken } from "atom.io/realtime"
-
-import type { ServerConfig, Socket } from ".."
-import { socketAtoms, usersOfSockets } from ".."
-import { userUnacknowledgedQueues } from "../realtime-server-stores"
-import { prepareToSendInitialPayload } from "./prepare-to-send-initial-payload"
-import { prepareToServeTransactionRequest } from "./prepare-to-serve-transaction-request"
-import { prepareToTrackClientAcknowledgement } from "./prepare-to-track-client-acknowledgement"
-import { subscribeToContinuityActions } from "./subscribe-to-continuity-actions"
-import { subscribeToContinuityPerspectives } from "./subscribe-to-continuity-perpectives"
-
-export type ExposeRealtimeContinuity = (
-	continuity: ContinuityToken,
-) => () => void
-export function prepareToExposeRealtimeContinuity({
-	socket: initialSocket,
-	store = IMPLICIT.STORE,
-}: ServerConfig): ExposeRealtimeContinuity {
-	return function syncRealtimeContinuity(continuity) {
-		let socket: Socket | null = initialSocket
-
-		const continuityKey = continuity.key
-		const userKeyState = findRelationsInStore(
-			usersOfSockets,
-			`socket::${socket.id}`,
-			store,
-		).userKeyOfSocket
-		const userKey = getFromStore(store, userKeyState)
-		if (!userKey) {
-			store.logger.error(
-				`❌`,
-				`continuity`,
-				continuityKey,
-				`Tried to create a synchronizer for a socket (${socket.id}) that is not connected to a user.`,
-			)
-			return () => {}
-		}
-
-		const socketKeyState = findRelationsInStore(
-			usersOfSockets,
-			userKey,
-			store,
-		).socketKeyOfUser
-		const _unsubscribeFromSocketTracking = subscribeToState(
-			store,
-			socketKeyState,
-			`sync-continuity:${continuityKey}:${userKey}`,
-			({ newValue: newSocketKey }) => {
-				store.logger.info(
-					`👋`,
-					`continuity`,
-					continuityKey,
-					`seeing ${userKey} on new socket ${newSocketKey}`,
-				)
-				if (newSocketKey === null) {
-					store.logger.warn(
-						`❌`,
-						`continuity`,
-						continuityKey,
-						`User (${userKey}) is not connected to a socket, waiting for them to reappear.`,
-					)
-					return
-				}
-				const newSocketState = findInStore(store, socketAtoms, newSocketKey)
-				const newSocket = getFromStore(store, newSocketState)
-				socket = newSocket
-				for (const unacknowledgedUpdate of userUnacknowledgedUpdates) {
-					socket?.emit(
-						`tx-new:${continuityKey}`,
-						unacknowledgedUpdate as Json.Serializable,
-					)
-				}
-			},
-		)
-
-		const userUnacknowledgedUpdates = getFromStore(
-			store,
-			userUnacknowledgedQueues,
-			userKey,
-		)
-
-		const unsubscribeFunctions: (() => void)[] = []
-
-		const unsubscribeFromPerspectives = subscribeToContinuityPerspectives(
-			store,
-			continuity,
-			userKey,
-			socket,
-		)
-		const unsubscribeFromTransactions = subscribeToContinuityActions(
-			store,
-			continuity,
-			userKey,
-			socket,
-		)
-		unsubscribeFunctions.push(
-			...unsubscribeFromPerspectives,
-			...unsubscribeFromTransactions,
-		)
-
-		const sendInitialPayload = prepareToSendInitialPayload(
-			store,
-			continuity,
-			userKey,
-			initialSocket,
-		)
-
-		socket.off(`get:${continuityKey}`, sendInitialPayload)
-		socket.on(`get:${continuityKey}`, sendInitialPayload)
-
-		const fillTransactionRequest = prepareToServeTransactionRequest(
-			store,
-			continuity,
-			userKey,
-		)
-
-		socket.off(`tx-run:${continuityKey}`, fillTransactionRequest)
-		socket.on(`tx-run:${continuityKey}`, fillTransactionRequest)
-
-		const trackClientAcknowledgement = prepareToTrackClientAcknowledgement(
-			store,
-			continuity,
-			userKey,
-			userUnacknowledgedUpdates,
-		)
-
-		socket?.on(`ack:${continuityKey}`, trackClientAcknowledgement)
-
-		return () => {
-			// clearInterval(retryTimeout)
-			for (const unsubscribe of unsubscribeFunctions) unsubscribe()
-			socket?.off(`ack:${continuityKey}`, trackClientAcknowledgement)
-			socket?.off(`get:${continuityKey}`, sendInitialPayload)
-			socket?.off(`tx-run:${continuityKey}`, fillTransactionRequest)
-		}
-	}
-}

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

@@ -1,41 +0,0 @@
-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"
-
-export function prepareToTrackClientAcknowledgement(
-	store: Store,
-	continuity: ContinuityToken,
-	userKey: UserKey,
-	userUnacknowledgedUpdates: ContinuitySyncTransactionUpdate[],
-): (epoch: number) => void {
-	const continuityKey = continuity.key
-	return function trackClientAcknowledgement(epoch) {
-		store.logger.info(
-			`👍`,
-			`continuity`,
-			continuityKey,
-			`${userKey} acknowledged epoch ${epoch}`,
-		)
-		const isUnacknowledged = userUnacknowledgedUpdates[0]?.epoch === epoch
-		if (isUnacknowledged) {
-			setIntoStore(store, userUnacknowledgedQueues, userKey, (updates) => {
-				updates.shift()
-				store.logger.info(
-					`👍`,
-					`continuity`,
-					continuityKey,
-					`${userKey} unacknowledged update queue now has`,
-					updates.length,
-					`items`,
-				)
-				return updates
-			})
-		}
-	}
-}

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

@@ -1,40 +0,0 @@
-import type { TransactionOutcomeEvent, TransactionToken } from "atom.io"
-import { actUponStore, IMPLICIT } from "atom.io/internal"
-import type { JsonIO } from "atom.io/json"
-
-import type { ServerConfig } from "."
-
-export type ActionReceiver = ReturnType<typeof realtimeActionReceiver>
-export function realtimeActionReceiver({
-	socket,
-	store = IMPLICIT.STORE,
-}: ServerConfig) {
-	return function actionReceiver<F extends JsonIO>(
-		tx: TransactionToken<F>,
-	): () => void {
-		const fillTransactionRequest = (
-			update: Pick<
-				TransactionOutcomeEvent<TransactionToken<F>>,
-				`id` | `params`
-			>,
-		) => {
-			const performanceKey = `tx-run:${tx.key}:${update.id}`
-			const performanceKeyStart = `${performanceKey}:start`
-			const performanceKeyEnd = `${performanceKey}:end`
-			performance.mark(performanceKeyStart)
-			actUponStore<F>(store, tx, update.id)(...update.params)
-			performance.mark(performanceKeyEnd)
-			const metric = performance.measure(
-				performanceKey,
-				performanceKeyStart,
-				performanceKeyEnd,
-			)
-			store?.logger.info(`🚀`, `transaction`, tx.key, update.id, metric.duration)
-		}
-		socket.on(`tx-run:${tx.key}`, fillTransactionRequest)
-
-		return () => {
-			socket.off(`tx-run:${tx.key}`, fillTransactionRequest)
-		}
-	}
-}

package/src/realtime-server/realtime-server-stores/server-room-external-actions.ts

@@ -1,79 +0,0 @@
-import type { Loadable } from "atom.io"
-import * as AtomIO from "atom.io"
-import { editRelationsInStore } from "atom.io/internal"
-import type { UserInRoomMeta } from "atom.io/realtime"
-import { roomIndex, usersInRooms } from "atom.io/realtime"
-
-import type { ChildSocket } from "../ipc-sockets"
-import type { RoomArguments } from "./server-room-external-store"
-import { roomArgumentsAtoms, roomSelectors } from "./server-room-external-store"
-import type { RoomKey } from "./server-user-store"
-
-export const createRoomTX: AtomIO.TransactionToken<
-	(
-		roomKey: RoomKey,
-		script: string,
-		options?: string[],
-	) => Loadable<ChildSocket<any, any>>
-> = AtomIO.transaction({
-	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.TransactionToken<
-	(roomId: string, userId: string, enteredAtEpoch: number) => UserInRoomMeta
-> = AtomIO.transaction({
-	key: `joinRoom`,
-	do: (tools, roomId, userId, enteredAtEpoch) => {
-		const meta = { enteredAtEpoch }
-		editRelationsInStore(
-			usersInRooms,
-			(relations) => {
-				relations.set({ room: roomId, user: userId }, meta)
-			},
-			tools.env().store,
-		)
-		return meta
-	},
-})
-export type JoinRoomIO = AtomIO.TransactionIO<typeof joinRoomTX>
-
-export const leaveRoomTX: AtomIO.TransactionToken<
-	(roomId: string, userId: string) => void
-> = AtomIO.transaction({
-	key: `leaveRoom`,
-	do: (tools, roomId, userId) => {
-		editRelationsInStore(
-			usersInRooms,
-			(relations) => {
-				relations.delete({ room: roomId, user: userId })
-			},
-			tools.env().store,
-		)
-	},
-})
-export type LeaveRoomIO = AtomIO.TransactionIO<typeof leaveRoomTX>
-
-export const destroyRoomTX: AtomIO.TransactionToken<(roomKey: RoomKey) => void> =
-	AtomIO.transaction({
-		key: `destroyRoom`,
-		do: (tools, roomKey) => {
-			editRelationsInStore(
-				usersInRooms,
-				(relations) => {
-					relations.delete({ room: roomKey })
-				},
-				tools.env().store,
-			)
-			tools.set(roomIndex, (s) => (s.delete(roomKey), s))
-		},
-	})