atom.io 0.21.0 → 0.22.0

package/data/src/join.ts

@@ -2,15 +2,17 @@
 import type {
 	MutableAtomFamily,
 	MutableAtomFamilyToken,
-	MutableAtomToken,
 	Read,
+	ReadableFamilyToken,
 	ReadonlySelectorFamily,
 	ReadonlySelectorToken,
 	RegularAtomFamily,
 	Transactors,
 	Write,
 } from "atom.io"
-import { disposeState, findState, getState, setState } from "atom.io"
+import { disposeState } from "atom.io"
+import type { findState } from "atom.io/ephemeral"
+import type { Molecule, seekState } from "atom.io/immortal"
 import type { Store } from "atom.io/internal"
 import {
 	createMutableAtomFamily,
@@ -20,11 +22,13 @@ import {
 	getFromStore,
 	getJsonFamily,
 	IMPLICIT,
+	initFamilyMember,
 	isChildStore,
 	newest,
+	seekInStore,
 	setIntoStore,
 } from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import { type Json, stringifyJson } from "atom.io/json"
 import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 
@@ -37,12 +41,6 @@ import type {
 import { Junction } from "~/packages/rel8/junction/src"
 import type * as Rel8 from "~/packages/rel8/types/src"
 
-const TRANSACTORS: Transactors = {
-	get: getState,
-	set: setState,
-	find: findState,
-}
-
 function capitalize<S extends string>(string: S): Capitalize<S> {
 	return (string[0].toUpperCase() + string.slice(1)) as Capitalize<S>
 }
@@ -135,6 +133,8 @@ export class Join<
 	private options: JoinOptions<ASide, BSide, Cardinality, Content>
 	private defaultContent: Content | undefined
 	private transactors: Transactors
+	public retrieve: typeof findState
+	public molecules: Map<string, Molecule<any>> = new Map()
 	public relations: Junction<ASide, BSide, Content>
 	public states: JoinStateFamilies<ASide, BSide, Cardinality, Content>
 	public core: {
@@ -154,7 +154,12 @@ export class Join<
 		this.transactors = originalTransactors
 	}
 
+	public store: Store
 	public alternates: Map<string, Join<ASide, BSide, Cardinality, Content>>
+	public [Symbol.dispose](): void {
+		this.alternates.delete(this.store.config.name)
+	}
+
 	public in(store: Store): Join<ASide, BSide, Cardinality, Content> {
 		const key = store.config.name
 		const alternate = this.alternates.get(key)
@@ -172,16 +177,38 @@ export class Join<
 		defaultContent: Content | undefined,
 		store: Store = IMPLICIT.STORE,
 	) {
+		this.store = store
 		this.options = options
 		this.defaultContent = defaultContent
 		this.alternates = new Map()
 		this.alternates.set(store.config.name, this)
+
+		this.store.miscResources.set(`join:${options.key}`, this)
+
 		this.transactors = {
 			get: (token) => getFromStore(token, store),
 			set: (token, value) => {
 				setIntoStore(token, value, store)
 			},
 			find: ((token, key) => findInStore(token, key, store)) as typeof findState,
+			seek: ((token, key) => seekInStore(token, key, store)) as typeof seekState,
+		}
+		this.retrieve = (
+			token: ReadableFamilyToken<any, any>,
+			key: Json.Serializable,
+		) => {
+			const maybeToken = this.transactors.seek(token, key)
+			if (maybeToken) {
+				return maybeToken
+			}
+			const molecule = this.molecules.get(stringifyJson(key))
+			if (!molecule) {
+				if (store.config.lifespan === `immortal`) {
+					throw new Error(`No molecule found for key "${stringifyJson(key)}"`)
+				}
+				return initFamilyMember(token, key, store)
+			}
+			return molecule.bond(token) as any
 		}
 		const aSide: ASide = options.between[0]
 		const bSide: BSide = options.between[1]
@@ -201,17 +228,17 @@ export class Join<
 		)
 		this.core = { findRelatedKeysState: relatedKeysAtoms }
 		const getRelatedKeys: Read<(key: string) => SetRTX<string>> = (
-			{ find, get },
+			{ get },
 			key,
-		) => get(find(relatedKeysAtoms, key))
+		) => get(this.retrieve(relatedKeysAtoms, key))
 		const addRelation: Write<(a: string, b: string) => void> = (
 			transactors,
 			a,
 			b,
 		) => {
-			const { set, find } = transactors
-			const aKeysState = find(relatedKeysAtoms, a)
-			const bKeysState = find(relatedKeysAtoms, b)
+			const { set } = transactors
+			const aKeysState = this.retrieve(relatedKeysAtoms, a)
+			const bKeysState = this.retrieve(relatedKeysAtoms, b)
 			set(aKeysState, (aKeys) => aKeys.add(b))
 			set(bKeysState, (bKeys) => bKeys.add(a))
 		}
@@ -220,24 +247,50 @@ export class Join<
 			a,
 			b,
 		) => {
-			const { find, set } = transactors
-			const aKeysState = find(relatedKeysAtoms, a)
-			const bKeysState = find(relatedKeysAtoms, b)
-			set(aKeysState, (aKeys) => (aKeys.delete(b), aKeys))
-			set(bKeysState, (bKeys) => (bKeys.delete(a), bKeys))
+			const { set } = transactors
+			const aKeysState = this.retrieve(relatedKeysAtoms, a)
+			const bKeysState = this.retrieve(relatedKeysAtoms, b)
+			let stringA: string | undefined
+			let stringB: string | undefined
+			set(aKeysState, (aKeys) => {
+				aKeys.delete(b)
+				if (aKeys.size === 0) {
+					stringA = `"${a}"`
+				}
+				return aKeys
+			})
+			set(bKeysState, (bKeys) => {
+				bKeys.delete(a)
+				if (bKeys.size === 0) {
+					stringB = `"${b}"`
+				}
+				return bKeys
+			})
+
+			if (stringA && this.molecules.has(stringA)) {
+				this.molecules.get(stringA)?.clear()
+				this.molecules.delete(stringA)
+			}
+			if (stringB && this.molecules.has(stringB)) {
+				this.molecules.get(stringB)?.clear()
+				this.molecules.delete(stringB)
+			}
 		}
 		const replaceRelationsSafely: Write<
 			(a: string, newRelationsOfA: string[]) => void
 		> = (transactors, a, newRelationsOfA) => {
-			const { find, get, set } = transactors
-			const relationsOfAState = find(relatedKeysAtoms, a)
+			const { get, set } = transactors
+			const relationsOfAState = this.retrieve(relatedKeysAtoms, a)
 			const currentRelationsOfA = get(relationsOfAState)
 			for (const currentRelationB of currentRelationsOfA) {
 				const remainsRelated = newRelationsOfA.includes(currentRelationB)
 				if (remainsRelated) {
 					continue
 				}
-				const relationsOfBState = find(relatedKeysAtoms, currentRelationB)
+				const relationsOfBState = this.retrieve(
+					relatedKeysAtoms,
+					currentRelationB,
+				)
 				set(relationsOfBState, (relationsOfB) => {
 					relationsOfB.delete(a)
 					return relationsOfB
@@ -250,6 +303,7 @@ export class Join<
 						const relationsOfB = getRelatedKeys(transactors, newRelationB)
 						const newRelationBIsAlreadyRelated = relationsOfB.has(a)
 						if (this.relations.cardinality === `1:n`) {
+							const previousOwnersToDispose: string[] = []
 							for (const previousOwner of relationsOfB) {
 								if (previousOwner === a) {
 									continue
@@ -259,10 +313,21 @@ export class Join<
 									previousOwner,
 								)
 								previousOwnerRelations.delete(newRelationB)
+								if (previousOwnerRelations.size === 0) {
+									previousOwnersToDispose.push(previousOwner)
+								}
 							}
 							if (!newRelationBIsAlreadyRelated && relationsOfB.size > 0) {
 								relationsOfB.clear()
 							}
+							for (const previousOwner of previousOwnersToDispose) {
+								const molecule = this.molecules.get(previousOwner)
+								molecule?.clear()
+								this.molecules.delete(previousOwner)
+								const sorted = [newRelationB, previousOwner].sort()
+								const compositeKey = `"${sorted[0]}:${sorted[1]}"`
+								this.molecules.delete(compositeKey)
+							}
 						}
 						if (!newRelationBIsAlreadyRelated) {
 							relationsOfB.add(a)
@@ -277,8 +342,8 @@ export class Join<
 		const replaceRelationsUnsafely: Write<
 			(a: string, newRelationsOfA: string[]) => void
 		> = (transactors, a, newRelationsOfA) => {
-			const { find, set } = transactors
-			const relationsOfAState = find(relatedKeysAtoms, a)
+			const { set } = transactors
+			const relationsOfAState = this.retrieve(relatedKeysAtoms, a)
 			set(relationsOfAState, (relationsOfA) => {
 				relationsOfA.transaction((nextRelationsOfA) => {
 					for (const newRelationB of newRelationsOfA) {
@@ -289,7 +354,7 @@ export class Join<
 				return relationsOfA
 			})
 			for (const newRelationB of newRelationsOfA) {
-				const newRelationsBState = find(relatedKeysAtoms, newRelationB)
+				const newRelationsBState = this.retrieve(relatedKeysAtoms, newRelationB)
 				set(newRelationsBState, (newRelationsB) => {
 					newRelationsB.add(a)
 					return newRelationsB
@@ -331,19 +396,21 @@ export class Join<
 				},
 				store,
 			)
-			const getContent: Read<(key: string) => Content | null> = (
-				{ find, get },
-				key,
-			) => get(find(contentAtoms, key))
+			const getContent: Read<(key: string) => Content | null> = ({ get }, key) =>
+				get(this.retrieve(contentAtoms, key))
 			const setContent: Write<(key: string, content: Content) => void> = (
-				{ find, set },
+				{ set },
 				key,
 				content,
 			) => {
-				set(find(contentAtoms, key), content)
+				set(this.retrieve(contentAtoms, key), content)
 			}
-			const deleteContent: Write<(key: string) => void> = ({ find }, key) => {
-				disposeState(find(contentAtoms, key))
+			const deleteContent: Write<(compositeKey: string) => void> = (
+				_,
+				compositeKey,
+			) => {
+				disposeState(this.retrieve(contentAtoms, compositeKey))
+				this.molecules.delete(`"${compositeKey}"`)
 			}
 			const externalStoreWithContentConfiguration = {
 				getContent: (contentKey: string) => {
@@ -367,7 +434,18 @@ export class Join<
 		}
 		const relations = new Junction<ASide, BSide, Content>(options, {
 			externalStore,
-			makeContentKey: (...args) => args.sort().join(`:`),
+			makeContentKey: (...args) => {
+				const sorted = args.sort()
+				const compositeKey = `${sorted[0]}:${sorted[1]}`
+				const [m0, m1] = sorted.map((key) =>
+					this.molecules.get(stringifyJson(key)),
+				)
+				if (store.config.lifespan === `immortal` && m0 && m1) {
+					const composite = m0.with(m1)(compositeKey)
+					this.molecules.set(`"${compositeKey}"`, composite)
+				}
+				return compositeKey
+			},
 		})
 
 		const createSingleKeyStateFamily = () =>
@@ -376,8 +454,8 @@ export class Join<
 					key: `${options.key}/singleRelatedKey`,
 					get:
 						(key) =>
-						({ find, get }) => {
-							const relatedKeysState = find(relatedKeysAtoms, key)
+						({ get }) => {
+							const relatedKeysState = this.retrieve(relatedKeysAtoms, key)
 							const relatedKeys = get(relatedKeysState)
 							for (const relatedKey of relatedKeys) {
 								return relatedKey
@@ -393,9 +471,9 @@ export class Join<
 					key: `${options.key}/multipleRelatedKeys`,
 					get:
 						(key) =>
-						({ find, get }) => {
+						({ get }) => {
 							const jsonFamily = getJsonFamily(relatedKeysAtoms, store)
-							const jsonState = find(jsonFamily, key)
+							const jsonState = this.retrieve(jsonFamily, key)
 							const json = get(jsonState)
 							return json.members
 						},
@@ -409,12 +487,12 @@ export class Join<
 					key: `${options.key}/singleRelatedEntry`,
 					get:
 						(key) =>
-						({ find, get }) => {
-							const relatedKeysState = find(relatedKeysAtoms, key)
+						({ get }) => {
+							const relatedKeysState = this.retrieve(relatedKeysAtoms, key)
 							const relatedKeys = get(relatedKeysState)
 							for (const relatedKey of relatedKeys) {
 								const contentKey = relations.makeContentKey(key, relatedKey)
-								const contentState = find(contentAtoms, contentKey)
+								const contentState = this.retrieve(contentAtoms, contentKey)
 								const content = get(contentState)
 								return [relatedKey, content]
 							}
@@ -429,12 +507,13 @@ export class Join<
 					key: `${options.key}/multipleRelatedEntries`,
 					get:
 						(key) =>
-						({ find, get }) => {
+						({ get }) => {
 							const jsonFamily = getJsonFamily(relatedKeysAtoms, store)
-							const json = get(jsonFamily(key))
+							const jsonState = this.retrieve(jsonFamily, key)
+							const json = get(jsonState)
 							return json.members.map((relatedKey) => {
 								const contentKey = relations.makeContentKey(key, relatedKey)
-								const contentState = find(contentAtoms, contentKey)
+								const contentState = this.retrieve(contentAtoms, contentKey)
 								const content = get(contentState)
 								return [relatedKey, content]
 							})
@@ -693,12 +772,12 @@ export function findRelationsInStore<
 			relations = {
 				get [keyAB]() {
 					const familyAB = myJoin.states[keyAB as any]
-					const state = findInStore(familyAB, key, store)
+					const state = myJoin.retrieve(familyAB, key)
 					return state
 				},
 				get [keyBA]() {
 					const familyBA = myJoin.states[keyBA as any]
-					const state = findInStore(familyBA, key, store)
+					const state = myJoin.retrieve(familyBA, key)
 					return state
 				},
 			} as JoinStates<ASide, BSide, Cardinality, Content>
@@ -708,12 +787,12 @@ export function findRelationsInStore<
 				Object.assign(relations, {
 					get [entryAB]() {
 						const familyAB = myJoin.states[entryAB as any]
-						const state = findInStore(familyAB, key, store)
+						const state = myJoin.retrieve(familyAB, key)
 						return state
 					},
 					get [entryBA]() {
 						const familyBA = myJoin.states[entryBA as any]
-						const state = findInStore(familyBA, key, store)
+						const state = myJoin.retrieve(familyBA, key)
 						return state
 					},
 				})
@@ -726,12 +805,12 @@ export function findRelationsInStore<
 			relations = {
 				get [keyAB]() {
 					const familyAB = myJoin.states[keyAB as any]
-					const state = findInStore(familyAB, key, store)
+					const state = myJoin.retrieve(familyAB, key)
 					return state
 				},
 				get [keysBA]() {
 					const familyBA = myJoin.states[keysBA as any]
-					const state = findInStore(familyBA, key, store)
+					const state = myJoin.retrieve(familyBA, key)
 					return state
 				},
 			} as JoinStates<ASide, BSide, Cardinality, Content>
@@ -741,12 +820,12 @@ export function findRelationsInStore<
 				Object.assign(relations, {
 					get [entryAB]() {
 						const familyAB = myJoin.states[entryAB as any]
-						const state = findInStore(familyAB, key, store)
+						const state = myJoin.retrieve(familyAB, key)
 						return state
 					},
 					get [entriesBA]() {
 						const familyBA = myJoin.states[entriesBA as any]
-						const state = findInStore(familyBA, key, store)
+						const state = myJoin.retrieve(familyBA, key)
 						return state
 					},
 				})
@@ -759,12 +838,12 @@ export function findRelationsInStore<
 			relations = {
 				get [keysAB]() {
 					const familyAB = myJoin.states[keysAB as any]
-					const state = findInStore(familyAB, key, store)
+					const state = myJoin.retrieve(familyAB, key)
 					return state
 				},
 				get [keysBA]() {
 					const familyBA = myJoin.states[keysBA as any]
-					const state = findInStore(familyBA, key, store)
+					const state = myJoin.retrieve(familyBA, key)
 					return state
 				},
 			} as JoinStates<ASide, BSide, Cardinality, Content>
@@ -774,12 +853,12 @@ export function findRelationsInStore<
 				Object.assign(relations, {
 					get [entriesAB]() {
 						const familyAB = myJoin.states[entriesAB as any]
-						const state = findInStore(familyAB, key, store)
+						const state = myJoin.retrieve(familyAB, key)
 						return state
 					},
 					get [entriesBA]() {
 						const familyBA = myJoin.states[entriesBA as any]
-						const state = findInStore(familyBA, key, store)
+						const state = myJoin.retrieve(familyBA, key)
 						return state
 					},
 				})

package/data/src/struct-family.ts

@@ -44,10 +44,10 @@ export function structFamily<
 				key: options.key,
 				get:
 					(id) =>
-					({ get }) => {
+					({ find, get }) => {
 						return Object.keys(options.default).reduce((acc, subKey) => {
 							acc[subKey] = get(
-								(atoms as any)[nameFamily(options.key, subKey)](id),
+								find((atoms as any)[nameFamily(options.key, subKey)], id),
 							)
 							return acc
 						}, {} as any)

package/dist/{chunk-RT43TVKP.js → chunk-GVHKIJ3G.js}

@@ -17,7 +17,7 @@ function syncContinuity(continuity, socket, store) {
       } else {
         v = x;
         if (`type` in k && k.type === `mutable_atom`) {
-          k = getJsonToken(k);
+          k = getJsonToken(k, store);
         }
         setIntoStore(k, v, store);
       }