atom.io 0.36.3 → 0.37.0

package/src/realtime-client/continuity/register-and-attempt-confirmed-update.ts

@@ -19,13 +19,23 @@ export const useRegisterAndAttemptConfirmedUpdate =
 		store: Store,
 		continuityKey: string,
 		socket: Socket,
-		optimisticUpdates: AtomIO.TransactionUpdate<any>[],
-		confirmedUpdates: AtomIO.TransactionUpdate<any>[],
+		optimisticUpdates: AtomIO.TransactionOutcomeEvent<
+			AtomIO.TransactionToken<Fn>
+		>[],
+		confirmedUpdates: AtomIO.TransactionOutcomeEvent<
+			AtomIO.TransactionToken<Fn>
+		>[],
 	) =>
-	(confirmed: AtomIO.TransactionUpdate<Fn>): void => {
+	(
+		confirmed: AtomIO.TransactionOutcomeEvent<AtomIO.TransactionToken<Fn>>,
+	): void => {
 		function reconcileEpoch(
-			optimisticUpdate: AtomIO.TransactionUpdate<any>,
-			confirmedUpdate: AtomIO.TransactionUpdate<any>,
+			optimisticUpdate: AtomIO.TransactionOutcomeEvent<
+				AtomIO.TransactionToken<Fn>
+			>,
+			confirmedUpdate: AtomIO.TransactionOutcomeEvent<
+				AtomIO.TransactionToken<Fn>
+			>,
 		): void {
 			store.logger.info(
 				`🧑‍⚖️`,
@@ -38,8 +48,8 @@ export const useRegisterAndAttemptConfirmedUpdate =
 				return queue
 			})
 			if (optimisticUpdate.id === confirmedUpdate.id) {
-				const clientResult = JSON.stringify(optimisticUpdate.updates)
-				const serverResult = JSON.stringify(confirmedUpdate.updates)
+				const clientResult = JSON.stringify(optimisticUpdate.subEvents)
+				const serverResult = JSON.stringify(confirmedUpdate.subEvents)
 				if (clientResult === serverResult) {
 					store.logger.info(
 						`✅`,
@@ -56,7 +66,7 @@ export const useRegisterAndAttemptConfirmedUpdate =
 					`❌`,
 					`continuity`,
 					continuityKey,
-					`thought update #${confirmedUpdate.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate.key}:${confirmedUpdate.id}`,
+					`thought update #${confirmedUpdate.epoch} was ${optimisticUpdate.token.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate.token.key}:${confirmedUpdate.id}`,
 				)
 			}
 			store.logger.info(
@@ -99,7 +109,7 @@ export const useRegisterAndAttemptConfirmedUpdate =
 			for (const subsequentOptimistic of optimisticUpdates) {
 				const token = {
 					type: `transaction`,
-					key: subsequentOptimistic.key,
+					key: subsequentOptimistic.token.key,
 				} as const
 				const { id, params } = subsequentOptimistic
 				actUponStore(store, token, id)(...params)
@@ -188,7 +198,7 @@ export const useRegisterAndAttemptConfirmedUpdate =
 					`✅`,
 					`continuity`,
 					continuityKey,
-					`integrating update #${confirmed.epoch} (${confirmed.key} ${confirmed.id})`,
+					`integrating update #${confirmed.epoch} (${confirmed.token.key} ${confirmed.id})`,
 				)
 				ingestTransactionUpdate(`newValue`, confirmed, store)
 				socket.emit(`ack:${continuityKey}`, confirmed.epoch)

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

@@ -1,15 +1,15 @@
 import * as AtomIO from "atom.io"
 
 export const optimisticUpdateQueue: AtomIO.RegularAtomToken<
-	AtomIO.TransactionUpdate<any>[]
-> = AtomIO.atom<AtomIO.TransactionUpdate<any>[]>({
+	AtomIO.TransactionOutcomeEvent<any>[]
+> = AtomIO.atom<AtomIO.TransactionOutcomeEvent<any>[]>({
 	key: `updateQueue`,
 	default: () => [],
 })
 
 export const confirmedUpdateQueue: AtomIO.RegularAtomToken<
-	AtomIO.TransactionUpdate<any>[]
-> = AtomIO.atom<AtomIO.TransactionUpdate<any>[]>({
+	AtomIO.TransactionOutcomeEvent<any>[]
+> = AtomIO.atom<AtomIO.TransactionOutcomeEvent<any>[]>({
 	key: `serverConfirmedUpdateQueue`,
 	default: () => [],
 })

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

@@ -102,7 +102,7 @@ export function syncContinuity(
 				}
 				socket.emit(`tx-run:${continuityKey}`, {
 					id: clientUpdate.id,
-					key: transaction.key,
+					token: transaction,
 					params: clientUpdate.params,
 				})
 			},

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

@@ -1,19 +1,25 @@
-import type { TransactionUpdate } from "atom.io"
+import type { TransactionOutcomeEvent, TransactionToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import { actUponStore } from "atom.io/internal"
-import type { JsonIO } from "atom.io/json"
+import type { Json, JsonIO } from "atom.io/json"
 import type { ContinuityToken } from "atom.io/realtime"
 
 export function prepareToServeTransactionRequest(
 	store: Store,
 	continuity: ContinuityToken,
 	userKey: string,
-): (update: Pick<TransactionUpdate<JsonIO>, `id` | `key` | `params`>) => void {
+): (
+	event: Json.Serializable &
+		Pick<
+			TransactionOutcomeEvent<TransactionToken<JsonIO>>,
+			`id` | `params` | `token`
+		>,
+) => void {
 	const continuityKey = continuity.key
-	return function serveTransactionRequest(update) {
-		store.logger.info(`🛎️`, `continuity`, continuityKey, `received`, update)
-		const transactionKey = update.key
-		const updateId = update.id
+	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`
@@ -23,7 +29,7 @@ export function prepareToServeTransactionRequest(
 				store,
 				{ type: `transaction`, key: transactionKey },
 				updateId,
-			)(...update.params)
+			)(...txOutcome.params)
 		} catch (thrown) {
 			if (thrown instanceof Error) {
 				store.logger.error(

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

@@ -2,13 +2,16 @@ import type { Store } from "atom.io/internal"
 import { setIntoStore } from "atom.io/internal"
 import type { ContinuityToken } from "atom.io/realtime"
 
-import type { ContinuitySyncTransactionUpdate } from "../realtime-server-stores"
+import type {
+	ContinuitySyncTransactionUpdate,
+	UserKey,
+} from "../realtime-server-stores"
 import { userUnacknowledgedQueues } from "../realtime-server-stores"
 
 export function prepareToTrackClientAcknowledgement(
 	store: Store,
 	continuity: ContinuityToken,
-	userKey: string,
+	userKey: UserKey,
 	userUnacknowledgedUpdates: ContinuitySyncTransactionUpdate[],
 ): (epoch: number) => void {
 	const continuityKey = continuity.key

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

@@ -59,7 +59,7 @@ export function subscribeToContinuityActions(
 						)
 					const redactedUpdates = redactTransactionUpdateContent(
 						visibleKeys,
-						update.updates,
+						update.subEvents,
 					)
 					const redactedUpdate = {
 						...update,

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

@@ -1,4 +1,4 @@
-import type * as AtomIO from "atom.io"
+import type { TransactionOutcomeEvent, TransactionToken } from "atom.io"
 import { actUponStore, IMPLICIT } from "atom.io/internal"
 import type { JsonIO } from "atom.io/json"
 
@@ -10,10 +10,13 @@ export function realtimeActionReceiver({
 	store = IMPLICIT.STORE,
 }: ServerConfig) {
 	return function actionReceiver<F extends JsonIO>(
-		tx: AtomIO.TransactionToken<F>,
+		tx: TransactionToken<F>,
 	): () => void {
 		const fillTransactionRequest = (
-			update: Pick<AtomIO.TransactionUpdate<F>, `id` | `params`>,
+			update: Pick<
+				TransactionOutcomeEvent<TransactionToken<F>>,
+				`id` | `params`
+			>,
 		) => {
 			const performanceKey = `tx-run:${tx.key}:${update.id}`
 			const performanceKeyStart = `${performanceKey}:start`

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

@@ -1,7 +1,7 @@
 import type {
 	RegularAtomFamilyToken,
-	TransactionUpdate,
-	TransactionUpdateContent,
+	TransactionOutcomeEvent,
+	TransactionSubEvent,
 } from "atom.io"
 import { atomFamily } from "atom.io"
 
@@ -17,20 +17,19 @@ import type { UserKey } from "./server-user-store"
 
 export function redactTransactionUpdateContent(
 	visibleStateKeys: string[],
-	updates: TransactionUpdateContent[],
-): TransactionUpdateContent[] {
+	updates: TransactionSubEvent[],
+): TransactionSubEvent[] {
 	return updates
-		.map((update): TransactionUpdateContent => {
+		.map((update): TransactionSubEvent => {
 			switch (update.type) {
-				case `transaction_update`: {
+				case `transaction_outcome`: {
 					const redacted = redactTransactionUpdateContent(
 						visibleStateKeys,
-						update.updates,
+						update.subEvents,
 					)
-					return { ...update, updates: redacted }
+					return { ...update, subEvents: redacted }
 				}
 				case `atom_update`:
-				case `selector_update`:
 				case `molecule_creation`:
 				case `molecule_disposal`:
 				case `molecule_transfer`:
@@ -42,13 +41,11 @@ export function redactTransactionUpdateContent(
 		.filter((update) => {
 			switch (update.type) {
 				case `atom_update`:
-				case `selector_update`:
-					return visibleStateKeys.includes(update.key)
 				case `state_creation`:
 				case `state_disposal`:
 					return visibleStateKeys.includes(update.token.key)
 				case `molecule_creation`:
-				case `transaction_update`:
+				case `transaction_outcome`:
 				case `molecule_disposal`:
 				case `molecule_transfer`:
 					return true
@@ -58,12 +55,12 @@ export function redactTransactionUpdateContent(
 
 export const redactorAtoms: RegularAtomFamilyToken<
 	{
-		occlude: (updates: TransactionUpdateContent[]) => TransactionUpdateContent[]
+		occlude: (updates: TransactionSubEvent[]) => TransactionSubEvent[]
 	},
 	UserKey
 > = atomFamily<
 	{
-		occlude: (updates: TransactionUpdateContent[]) => TransactionUpdateContent[]
+		occlude: (updates: TransactionSubEvent[]) => TransactionSubEvent[]
 	},
 	UserKey
 >({
@@ -89,8 +86,8 @@ export const redactorAtoms: RegularAtomFamilyToken<
 // })
 
 export type ContinuitySyncTransactionUpdate = Pick<
-	TransactionUpdate<any>,
-	`epoch` | `id` | `key` | `output` | `updates`
+	TransactionOutcomeEvent<any>,
+	`epoch` | `id` | `output` | `subEvents` | `token`
 >
 export const userUnacknowledgedQueues: RegularAtomFamilyToken<
 	ContinuitySyncTransactionUpdate[],

package/src/transceivers/set-rtx/set-rtx.ts

@@ -51,9 +51,7 @@ export class SetRTX<P extends primitive>
 		}
 	}
 
-	public view(): SetRTXView<P> {
-		return this
-	}
+	public readonly READONLY_VIEW: SetRTXView<P> = this
 
 	public toJSON(): SetRTXJson<P> {
 		return {

package/src/web/persist-sync.ts

@@ -1,7 +1,7 @@
-import type { AtomEffect } from "atom.io"
+import type { AtomEffect, ViewOf } from "atom.io"
 
 export type StringInterface<T> = {
-	stringify: (t: T) => string
+	stringify: (t: ViewOf<T>) => string
 	parse: (s: string) => T
 }
 

package/src/internal/set-state/emit-update.ts

@@ -1,40 +0,0 @@
-import type { StateUpdate } from "atom.io"
-
-import type { Atom, Selector, Store } from ".."
-
-export const emitUpdate = <T>(
-	store: Store,
-	state: Atom<T> | Selector<T>,
-	update: StateUpdate<T>,
-): void => {
-	switch (state.type) {
-		case `mutable_atom`:
-			store.logger.info(
-				`📢`,
-				state.type,
-				state.key,
-				`is now (`,
-				update.newValue,
-				`) subscribers:`,
-				state.subject.subscribers,
-			)
-			break
-		case `atom`:
-		case `writable_pure_selector`:
-		case `readonly_pure_selector`:
-		case `writable_held_selector`:
-		case `readonly_held_selector`:
-			store.logger.info(
-				`📢`,
-				state.type,
-				state.key,
-				`went (`,
-				update.oldValue,
-				`->`,
-				update.newValue,
-				`) subscribers:`,
-				state.subject.subscribers,
-			)
-	}
-	state.subject.next(update)
-}