atom.io 0.17.0 → 0.18.1

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

@@ -5,13 +5,12 @@ import {
 	getFromStore,
 	subscribeToState,
 } from "atom.io/internal"
-import type { Json } from "atom.io/json"
-import { parseJson } from "atom.io/json"
+import { type Json, stringifyJson } from "atom.io/json"
 
 import type { ServerConfig } from "."
 
-export type FamilyProvider = ReturnType<typeof realtimeFamilyProvider>
-export function realtimeFamilyProvider({
+export type FamilyProvider = ReturnType<typeof realtimeAtomFamilyProvider>
+export function realtimeAtomFamilyProvider({
 	socket,
 	store = IMPLICIT.STORE,
 }: ServerConfig) {
@@ -19,77 +18,40 @@ export function realtimeFamilyProvider({
 		J extends Json.Serializable,
 		K extends Json.Serializable,
 	>(
-		family: AtomIO.RegularAtomFamily<J, K>,
+		family: AtomIO.RegularAtomFamilyToken<J, K>,
 		index: AtomIO.ReadableToken<Iterable<K>>,
 	): () => void {
-		const unsubSingleCallbacksByKey = new Map<string, () => void>()
-		const unsubFamilyCallbacksByKey = new Map<string, () => void>()
+		const unsubCallbacksByKey = new Map<string, () => void>()
 
-		const fillFamilyUnsubRequest = () => {
-			for (const [, unsub] of unsubFamilyCallbacksByKey) {
-				unsub()
-			}
-			unsubFamilyCallbacksByKey.clear()
-			socket.off(`unsub:${family.key}`, fillFamilyUnsubRequest)
-		}
-
-		const fillSingleUnsubRequest = (key: string) => {
-			socket.off(`unsub:${key}`, fillSingleUnsubRequest)
-			const unsub = unsubSingleCallbacksByKey.get(key)
+		const fillUnsubRequest = (key: string) => {
+			socket.off(`unsub:${key}`, fillUnsubRequest)
+			const unsub = unsubCallbacksByKey.get(key)
 			if (unsub) {
 				unsub()
-				unsubSingleCallbacksByKey.delete(key)
+				unsubCallbacksByKey.delete(key)
 			}
 		}
 
-		const fillSubRequest = (subKey?: K) => {
-			if (subKey === undefined) {
-				const keys = getFromStore(index, store)
-				for (const key of keys) {
-					const token = findInStore(family, key, store)
-					socket.emit(
-						`serve:${family.key}`,
-						parseJson(token.family?.subKey || `null`),
-						getFromStore(token, store),
+		const fillSubRequest = (subKey: K) => {
+			const exposedSubKeys = getFromStore(index, store)
+			for (const exposedSubKey of exposedSubKeys) {
+				if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) {
+					const token = findInStore(family, subKey, store)
+					socket.emit(`serve:${token.key}`, getFromStore(token, store))
+					const unsubscribe = subscribeToState(
+						token,
+						({ newValue }) => {
+							socket.emit(`serve:${token.key}`, newValue)
+						},
+						`expose-family:${family.key}:${socket.id}`,
+						store,
 					)
+					unsubCallbacksByKey.set(token.key, unsubscribe)
+					socket.on(`unsub:${token.key}`, () => {
+						fillUnsubRequest(token.key)
+					})
+					break
 				}
-
-				const unsubscribeFromTokenCreation = family.subject.subscribe(
-					`expose-family:${socket.id}`,
-					(token: AtomIO.WritableToken<J>) => {
-						const unsub = subscribeToState(
-							token,
-							({ newValue }) => {
-								socket.emit(
-									`serve:${family.key}`,
-									parseJson(token.family?.subKey || `null`),
-									newValue,
-								)
-							},
-							`expose-family:${family.key}:${socket.id}`,
-							store,
-						)
-						unsubFamilyCallbacksByKey.set(token.key, unsub)
-					},
-				)
-				unsubFamilyCallbacksByKey.set(family.key, unsubscribeFromTokenCreation)
-
-				socket.on(`unsub:${family.key}`, fillFamilyUnsubRequest)
-			} else {
-				const token = family(subKey)
-				socket.emit(`serve:${token.key}`, getFromStore(token, store))
-				const unsubscribe = subscribeToState(
-					token,
-					({ newValue }) => {
-						socket.emit(`serve:${token.key}`, newValue)
-					},
-					`expose-family:${family.key}:${socket.id}`,
-					store,
-				)
-				unsubSingleCallbacksByKey.set(token.key, unsubscribe)
-				socket.on(`unsub:${token.key}`, () => {
-					fillSingleUnsubRequest(token.key)
-				})
 			}
 		}
 
@@ -97,14 +59,11 @@ export function realtimeFamilyProvider({
 
 		return () => {
 			socket.off(`sub:${family.key}`, fillSubRequest)
-			for (const [, unsub] of unsubFamilyCallbacksByKey) {
-				unsub()
-			}
-			for (const [, unsub] of unsubSingleCallbacksByKey) {
+
+			for (const [, unsub] of unsubCallbacksByKey) {
 				unsub()
 			}
-			unsubFamilyCallbacksByKey.clear()
-			unsubSingleCallbacksByKey.clear()
+			unsubCallbacksByKey.clear()
 		}
 	}
 }

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

@@ -9,7 +9,7 @@ import {
 	subscribeToState,
 } from "atom.io/internal"
 import type { Json } from "atom.io/json"
-import { parseJson } from "atom.io/json"
+import { stringifyJson } from "atom.io/json"
 
 import type { ServerConfig } from "."
 
@@ -25,100 +25,42 @@ export function realtimeMutableFamilyProvider({
 		J extends Json.Serializable,
 		K extends Json.Serializable,
 	>(
-		family: AtomIO.MutableAtomFamily<T, J, K>,
+		family: AtomIO.MutableAtomFamilyToken<T, J, K>,
 		index: AtomIO.ReadableToken<Iterable<K>>,
 	): () => void {
-		const unsubSingleCallbacksByKey = new Map<string, () => void>()
-		const unsubFamilyCallbacksByKey = new Map<string, () => void>()
+		const unsubCallbacksByKey = new Map<string, () => void>()
 
-		const fillFamilyUnsubRequest = () => {
-			for (const [, unsub] of unsubFamilyCallbacksByKey) {
-				unsub()
-			}
-			unsubFamilyCallbacksByKey.clear()
-			socket.off(`unsub:${family.key}`, fillFamilyUnsubRequest)
-		}
-
-		const fillSingleUnsubRequest = (key: string) => {
-			socket.off(`unsub:${key}`, fillSingleUnsubRequest)
-			const unsub = unsubSingleCallbacksByKey.get(key)
+		const fillUnsubRequest = (key: string) => {
+			socket.off(`unsub:${key}`, fillUnsubRequest)
+			const unsub = unsubCallbacksByKey.get(key)
 			if (unsub) {
 				unsub()
-				unsubSingleCallbacksByKey.delete(key)
+				unsubCallbacksByKey.delete(key)
 			}
 		}
 
-		const fillSubRequest = (subKey?: K) => {
-			if (subKey === undefined) {
-				const keys = getFromStore(index, store)
-				for (const key of keys) {
-					const token = findInStore(family, key, store)
+		const fillSubRequest = (subKey: K) => {
+			const exposedSubKeys = getFromStore(index, store)
+			for (const exposedSubKey of exposedSubKeys) {
+				if (stringifyJson(exposedSubKey) === stringifyJson(subKey)) {
+					const token = findInStore(family, subKey, store)
 					const jsonToken = getJsonToken(token)
-					const trackerToken = getUpdateToken(token)
-					socket.emit(
-						`init:${family.key}`,
-						parseJson(jsonToken.family?.subKey || `null`),
-						getFromStore(jsonToken, store),
-					)
-					const unsubFromUpdates = subscribeToState(
-						trackerToken,
+					const updateToken = getUpdateToken(token)
+					socket.emit(`init:${token.key}`, getFromStore(jsonToken, store))
+					const unsubscribe = subscribeToState(
+						updateToken,
 						({ newValue }) => {
-							socket.emit(
-								`next:${token.key}`,
-								parseJson(jsonToken.family?.subKey || `null`),
-								newValue,
-							)
+							socket.emit(`next:${token.key}`, newValue)
 						},
 						`expose-family:${family.key}:${socket.id}`,
 						store,
 					)
-					unsubFamilyCallbacksByKey.set(token.key, unsubFromUpdates)
+					unsubCallbacksByKey.set(token.key, unsubscribe)
+					socket.on(`unsub:${token.key}`, () => {
+						fillUnsubRequest(token.key)
+					})
+					break
 				}
-				const unsubscribeFromTokenCreation = family.subject.subscribe(
-					`expose-family:${socket.id}`,
-					(token) => {
-						const jsonToken = getJsonToken(token)
-						const trackerToken = getUpdateToken(token)
-						socket.emit(
-							`init:${family.key}`,
-							parseJson(jsonToken.family?.subKey || `null`),
-							getFromStore(jsonToken, store),
-						)
-						const unsubFromUpdates = subscribeToState(
-							trackerToken,
-							({ newValue }) => {
-								socket.emit(
-									`next:${token.key}`,
-									parseJson(jsonToken.family?.subKey || `null`),
-									newValue,
-								)
-							},
-							`expose-family:${family.key}:${socket.id}`,
-							store,
-						)
-						unsubFamilyCallbacksByKey.set(token.key, unsubFromUpdates)
-					},
-				)
-				unsubFamilyCallbacksByKey.set(family.key, unsubscribeFromTokenCreation)
-
-				socket.on(`unsub:${family.key}`, fillFamilyUnsubRequest)
-			} else {
-				const token = family(subKey)
-				const jsonToken = getJsonToken(token)
-				const updateToken = getUpdateToken(token)
-				socket.emit(`init:${token.key}`, getFromStore(jsonToken, store))
-				const unsubscribe = subscribeToState(
-					updateToken,
-					({ newValue }) => {
-						socket.emit(`next:${token.key}`, newValue)
-					},
-					`expose-family:${family.key}:${socket.id}`,
-					store,
-				)
-				unsubSingleCallbacksByKey.set(token.key, unsubscribe)
-				socket.on(`unsub:${token.key}`, () => {
-					fillSingleUnsubRequest(token.key)
-				})
 			}
 		}
 
@@ -126,14 +68,10 @@ export function realtimeMutableFamilyProvider({
 
 		return () => {
 			socket.off(`sub:${family.key}`, fillSubRequest)
-			for (const [, unsub] of unsubFamilyCallbacksByKey) {
-				unsub()
-			}
-			for (const [, unsub] of unsubSingleCallbacksByKey) {
+			for (const [, unsub] of unsubCallbacksByKey) {
 				unsub()
 			}
-			unsubFamilyCallbacksByKey.clear()
-			unsubSingleCallbacksByKey.clear()
+			unsubCallbacksByKey.clear()
 		}
 	}
 }

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

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

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

@@ -0,0 +1,109 @@
+import { selectorFamily } from "atom.io"
+import type { TransactionUpdate } from "atom.io"
+import { IMPLICIT, getJsonToken, getUpdateToken } from "atom.io/internal"
+import type { JsonIO } from "atom.io/json"
+import { SyncGroup } from "atom.io/realtime"
+// import { completeUpdateAtoms } from "atom.io/realtime-server"
+
+const redactorAtoms = selectorFamily<
+	(update: TransactionUpdate<any>) => TransactionUpdate<any>,
+	{ userId: string; syncGroupKey: string }
+>({
+	key: `perspectiveRedactor`,
+	get:
+		({ userId, syncGroupKey }) =>
+		({ get, find }) => {
+			const syncGroup = SyncGroup.existing.get(syncGroupKey)
+			if (!syncGroup) {
+				throw new Error(
+					`Tried to create a synchronizer for a sync group that does not exist.`,
+				)
+			}
+
+			const userPerspectiveTokens = syncGroup.perspectives.flatMap(
+				({ viewAtoms }) => {
+					const userPerspectiveToken = find(viewAtoms, userId)
+					const userPerspective = get(userPerspectiveToken)
+					const visibleTokens = [...userPerspective].map((token) => {
+						return token.type === `mutable_atom`
+							? getUpdateToken(token).key
+							: token.key
+					})
+					IMPLICIT.STORE.logger.info(
+						`🔭`,
+						`continuity`,
+						syncGroupKey,
+						`${userId} can see ${visibleTokens.length} tokens in ${viewAtoms.key}`,
+						visibleTokens,
+					)
+					return visibleTokens
+				},
+			)
+
+			const filterTransactionUpdate = (
+				visible: string[],
+				transactionUpdate: TransactionUpdate<any>,
+			): TransactionUpdate<any> => {
+				IMPLICIT.STORE.logger.info(
+					`🖌`,
+					`continuity`,
+					syncGroupKey,
+					`redacting updates from ${transactionUpdate.epoch}:${transactionUpdate.key}:${transactionUpdate.id}`,
+					visible,
+					transactionUpdate.updates,
+				)
+				const updates = transactionUpdate.updates
+					.filter((update) => {
+						if (`newValue` in update) {
+							return visible.includes(update.key)
+						}
+						return true
+					})
+					.map((update) => {
+						if (`updates` in update) {
+							return filterTransactionUpdate(visible, update)
+						}
+						return update
+					})
+				const filtered: TransactionUpdate<any> = {
+					...transactionUpdate,
+					updates,
+				}
+				return filtered
+			}
+			const filter: (updates: TransactionUpdate<any>) => TransactionUpdate<any> =
+				(update) => {
+					const visibleKeys: string[] = syncGroup.globals.map((atomToken) =>
+						atomToken.type === `mutable_atom`
+							? getUpdateToken(atomToken).key
+							: atomToken.key,
+					)
+					visibleKeys.push(...userPerspectiveTokens)
+					return filterTransactionUpdate(visibleKeys, update)
+				}
+			return filter
+		},
+})
+// export const occludedUpdateSelectors = selectorFamily<
+// 	Pick<
+// 		TransactionUpdate<JsonIO>,
+// 		`epoch` | `id` | `key` | `output` | `updates`
+// 	> | null,
+// 	{ userId: string; syncGroupKey: string; updateId: string }
+// >({
+// 	key: `occludedUpdate`,
+// 	get:
+// 		({ userId, syncGroupKey, updateId }) =>
+// 		({ get, find }) => {
+// 			const updateState = find(completeUpdateAtoms, updateId)
+// 			const update = get(updateState)
+// 			const redactorKey = { userId, syncGroupKey }
+// 			const redactorState = find(redactorAtoms, redactorKey)
+// 			const redact = get(redactorState)
+// 			if (update) {
+// 				// return redact(update)
+// 				return update
+// 			}
+// 			return null
+// 		},
+// })

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

@@ -0,0 +1,64 @@
+import * as AtomIO from "atom.io"
+import type { Loadable } from "atom.io/data"
+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"
+
+export const createRoomTX = AtomIO.transaction<
+	(
+		roomId: string,
+		script: string,
+		options?: string[],
+	) => Loadable<ChildSocket<any, any>>
+>({
+	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>
+
+export const leaveRoomTX = AtomIO.transaction<
+	(roomId: string, userId: string) => void
+>({
+	key: `leaveRoom`,
+	do: (transactors, roomId, userId) => {
+		usersInRooms.transact(transactors, ({ relations }) => {
+			relations.delete({ room: roomId, user: userId })
+		})
+	},
+})
+export type LeaveRoomIO = AtomIO.TransactionIO<typeof leaveRoomTX>
+
+export const destroyRoomTX = AtomIO.transaction<(roomId: string) => void>({
+	key: `destroyRoom`,
+	do: (transactors, roomId) => {
+		usersInRooms.transact(transactors, ({ relations }) => {
+			relations.delete({ room: roomId })
+		})
+		transactors.set(roomIndex, (s) => (s.delete(roomId), s))
+	},
+})

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

@@ -0,0 +1,42 @@
+import type { ChildProcessWithoutNullStreams } from "child_process"
+import { spawn } from "child_process"
+
+import { atomFamily, selectorFamily } from "atom.io"
+import type { Loadable } from "atom.io/data"
+import { ChildSocket } from "../ipc-sockets"
+
+export type RoomArguments =
+	| [script: string, options: string[]]
+	| [script: string]
+
+export const roomArgumentsAtoms = atomFamily<RoomArguments, string>({
+	key: `roomArguments`,
+	default: [`echo`, [`Hello World!`]],
+})
+
+export const roomSelectors = selectorFamily<
+	Loadable<ChildSocket<any, any>>,
+	string
+>({
+	key: `room`,
+	get:
+		(roomId) =>
+		async ({ get, find }) => {
+			const argumentsState = find(roomArgumentsAtoms, roomId)
+			const args = get(argumentsState)
+			const [script, options] = args
+			const child = await new Promise<ChildProcessWithoutNullStreams>(
+				(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)
+				},
+			)
+			return new ChildSocket(child, roomId)
+		},
+})

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

@@ -1,115 +1,68 @@
 import type { TransactionUpdate, TransactionUpdateContent } from "atom.io"
 import { atomFamily, selectorFamily } from "atom.io"
-import { SyncGroup } from "~/packages/atom.io/__unstable__/realtime-server-next/create-realtime-sync-group"
-import { usersOfSockets } from "./server-user-store"
 
-export const completeUpdateAtoms = atomFamily<
-	TransactionUpdate<any> | null,
-	string
->({
-	key: `completeUpdate`,
-	default: null,
-})
+// export const completeUpdateAtoms = atomFamily<
+// 	TransactionUpdate<any> | null,
+// 	string
+// >({
+// 	key: `completeUpdate`,
+// 	default: null,
+// })
+
+export function redactTransactionUpdateContent(
+	visibleStateKeys: string[],
+	updates: TransactionUpdateContent[],
+): TransactionUpdateContent[] {
+	return updates
+		.map((update): TransactionUpdateContent => {
+			if (`newValue` in update) {
+				return update
+			}
+			const redacted = redactTransactionUpdateContent(
+				visibleStateKeys,
+				update.updates,
+			)
+			return { ...update, updates: redacted }
+		})
+		.filter((update) => {
+			if (`newValue` in update) {
+				return visibleStateKeys.includes(update.key)
+			}
+			return true
+		})
+}
 
-export const transactionRedactorAtoms = atomFamily<
+export const actionOcclusionAtoms = atomFamily<
 	{
-		filter: (updates: TransactionUpdateContent[]) => TransactionUpdateContent[]
+		occlude: (updates: TransactionUpdateContent[]) => TransactionUpdateContent[]
 	},
 	string
 >({
 	key: `transactionRedactor`,
-	default: { filter: (updates) => updates },
+	default: { occlude: (updates) => updates },
 })
-export const redactedUpdateSelectors = selectorFamily<
-	TransactionUpdate<any> | null,
-	[transactionKey: string, updateId: string]
->({
-	key: `redactedUpdate`,
-	get:
-		([transactionKey, updateId]) =>
-		({ get, find }) => {
-			const update = get(find(completeUpdateAtoms, updateId))
-			const { filter } = get(find(transactionRedactorAtoms, transactionKey))
+// export const redactedUpdateSelectors = selectorFamily<
+// 	TransactionUpdate<any> | null,
+// 	[transactionKey: string, updateId: string]
+// >({
+// 	key: `redactedUpdate`,
+// 	get:
+// 		([transactionKey, updateId]) =>
+// 		({ get, find }) => {
+// 			const update = get(find(completeUpdateAtoms, updateId))
+// 			const { filter } = get(find(transactionRedactorAtoms, transactionKey))
 
-			if (update && filter) {
-				return { ...update, updates: filter(update.updates) }
-			}
-			return null
-		},
-})
+// 			if (update && filter) {
+// 				return { ...update, updates: filter(update.updates) }
+// 			}
+// 			return null
+// 		},
+// })
 
-export const userUnacknowledgedUpdatesAtoms = atomFamily<
-	TransactionUpdate<any>[],
+export const userUnacknowledgedQueues = atomFamily<
+	Pick<TransactionUpdate<any>, `epoch` | `id` | `key` | `output` | `updates`>[],
 	string
 >({
 	key: `unacknowledgedUpdates`,
 	default: () => [],
 })
-
-export const socketUnacknowledgedUpdatesSelectors = selectorFamily<
-	TransactionUpdate<any>[],
-	string
->({
-	key: `socketUnacknowledgedUpdates`,
-	get:
-		(socketId) =>
-		({ get, find }) => {
-			const userKeyState = find(usersOfSockets.states.userKeyOfSocket, socketId)
-			const userKey = get(userKeyState)
-			if (!userKey) {
-				return []
-			}
-			const unacknowledgedUpdatesState = find(
-				userUnacknowledgedUpdatesAtoms,
-				userKey,
-			)
-			const unacknowledgedUpdates = get(unacknowledgedUpdatesState)
-			return unacknowledgedUpdates
-		},
-	set:
-		(socketId) =>
-		({ set, get, find }, newUpdates) => {
-			const userKeyState = find(usersOfSockets.states.userKeyOfSocket, socketId)
-			const userKey = get(userKeyState)
-			if (!userKey) {
-				return
-			}
-			const unacknowledgedUpdatesState = find(
-				userUnacknowledgedUpdatesAtoms,
-				userKey,
-			)
-			set(unacknowledgedUpdatesState, newUpdates)
-		},
-})
-
-export const userEpochAtoms = atomFamily<number | null, string>({
-	key: `clientEpoch`,
-	default: null,
-})
-
-export const socketEpochSelectors = selectorFamily<number | null, string>({
-	key: `socketEpoch`,
-	get:
-		(socketId) =>
-		({ get, find }) => {
-			const userKeyState = find(usersOfSockets.states.userKeyOfSocket, socketId)
-			const userKey = get(userKeyState)
-			if (!userKey) {
-				return null
-			}
-			const userEpochState = find(userEpochAtoms, userKey)
-			const userEpoch = get(userEpochState)
-			return userEpoch
-		},
-	set:
-		(socketId) =>
-		({ set, get, find }, newEpoch) => {
-			const userKeyState = find(usersOfSockets.states.userKeyOfSocket, socketId)
-			const userKey = get(userKeyState)
-			if (!userKey) {
-				return
-			}
-			const userEpochState = find(userEpochAtoms, userKey)
-			set(userEpochState, newEpoch)
-		},
-})