@chipmobilesdk/rn-local-db 0.1.1 → 0.2.0

package/src/testing/memory-adapter/index.ts

@@ -6,6 +6,7 @@
  * (research.md R8). Documented divergences are listed in the package README.
  */
 
+import { createTransactionQueue } from '../../sqlite/transaction-queue';
 import type {
 	AttachmentInput,
 	AttachmentReference,
@@ -116,7 +117,47 @@ export function createMemoryAdapter(options: MemoryAdapterOptions = {}): Storage
 			}
 		};
 
-		const collectionFor = <T extends StorableRecordData>(name: string): CollectionOps<T> => {
+		/**
+		 * The same isolation the SQLite connection gives: a transaction holds the
+		 * handle until it settles, and work through the handle meanwhile waits
+		 * rather than landing inside the transaction's snapshot and vanishing
+		 * with its rollback. Only what the transaction hands out runs inside it.
+		 */
+		const queue = createTransactionQueue();
+		const queued = <O extends object>(ops: O): O =>
+			Object.fromEntries(
+				Object.entries(ops).map(([key, value]) => [
+					key,
+					typeof value === 'function'
+						? (...args: unknown[]) =>
+								queue.run(() => (value as (...a: unknown[]) => Promise<unknown>)(...args))
+						: value,
+				]),
+			) as O;
+
+		/** Artifact deletions held back until the transaction that caused them commits. */
+		type Deferred = { add(id: string): void };
+
+		/** FR-070 for the memory adapter, with the SQLite adapter's ordering and reporting. */
+		const cascadeFor = (collection: string, id: string, deferred?: Deferred): DeletionOutcome => {
+			const removedArtifacts: string[] = [];
+			for (const reference of [...store.attachments.values()]) {
+				if (reference.owner?.collection !== collection || reference.owner?.id !== id) continue;
+				store.attachments.delete(reference.id);
+				if (deferred) {
+					deferred.add(reference.id);
+				} else {
+					store.artifacts.delete(reference.id);
+				}
+				removedArtifacts.push(reference.id);
+			}
+			return { removedRecords: 0, removedArtifacts, orphanedReferences: [], failedRemovals: [] };
+		};
+
+		const rawCollectionFor = <T extends StorableRecordData>(
+			name: string,
+			deferred?: Deferred,
+		): CollectionOps<T> => {
 			assertOpen();
 			const schema = schemas.get(name);
 			if (!schema) {
@@ -125,7 +166,7 @@ export function createMemoryAdapter(options: MemoryAdapterOptions = {}): Storage
 					detail: { collection: name },
 				});
 			}
-			return instrument(
+			const ops = instrument(
 				name,
 				'memory',
 				createMemoryCollection<T>({ store, schema, now, assertOpen }) as unknown as Record<
@@ -133,15 +174,28 @@ export function createMemoryAdapter(options: MemoryAdapterOptions = {}): Storage
 					(...args: never[]) => unknown
 				>,
 			) as unknown as CollectionOps<T>;
+			if (config.cascadeAttachments !== true) {
+				return ops;
+			}
+			return {
+				...ops,
+				async delete(id: string) {
+					const outcome = await ops.delete(id);
+					return { ...outcome, cascade: cascadeFor(name, id, deferred) };
+				},
+			};
 		};
 
+		const collectionFor = <T extends StorableRecordData>(name: string): CollectionOps<T> =>
+			queued(rawCollectionFor<T>(name));
+
 		const backupPosture: EffectivePosture = {
 			requested: store.backupIncluded ? 'included' : 'excluded',
 			observed: store.backupIncluded ? 'included' : 'excluded',
 			enforcedBy: 'package',
 		};
 
-		const attachments: Attachments = {
+		const rawAttachments = (deferred?: Deferred): Attachments => ({
 			async write(input: AttachmentInput): Promise<AttachmentReference> {
 				assertOpen();
 				throwIfFaulted('attachmentWrite');
@@ -191,6 +245,16 @@ export function createMemoryAdapter(options: MemoryAdapterOptions = {}): Storage
 			async remove(id: string): Promise<DeletionOutcome> {
 				assertOpen();
 				assertValidAttachmentId(id);
+				if (deferred) {
+					const hadReference = store.attachments.delete(id);
+					if (hadReference) deferred.add(id);
+					return {
+						removedRecords: 0,
+						removedArtifacts: hadReference ? [id] : [],
+						orphanedReferences: [],
+						failedRemovals: [],
+					};
+				}
 				const removed = store.artifacts.delete(id);
 				store.attachments.delete(id);
 				return {
@@ -225,6 +289,85 @@ export function createMemoryAdapter(options: MemoryAdapterOptions = {}): Storage
 				}
 				return { orphanedArtifacts, danglingReferences, removedArtifacts };
 			},
+		});
+		const attachments = queued(rawAttachments());
+
+		/**
+		 * One transaction against the store. Snapshot-and-restore rather than a
+		 * write log: simpler to reason about, and rollback fidelity is what US4
+		 * tests. Runs only inside `exclusive`, so the snapshot never captures,
+		 * nor its restore erases, a write made from outside.
+		 */
+		const runTransaction = async <R>(fn: (tx: Transaction) => Promise<R>): Promise<R> => {
+			const snapshot = cloneCollections(store);
+			const attachmentSnapshot = new Map(store.attachments);
+			const pendingArtifactRemovals: string[] = [];
+			const deferred: Deferred = { add: id => pendingArtifactRemovals.push(id) };
+			let settled = false;
+
+			const assertLive = (): void => {
+				if (settled) {
+					raise(DiagnosticCodes.TRANSACTION_STATE, {
+						message: 'transaction already settled',
+					});
+				}
+			};
+			const rollback = (): void => {
+				store.collections = snapshot as never;
+				store.attachments = attachmentSnapshot;
+			};
+
+			// A collection taken from the transaction keeps refusing once it
+			// settles, as the SQLite executor does; otherwise a write after abort
+			// would land straight in the store.
+			const live = <O extends object>(ops: O): O =>
+				Object.fromEntries(
+					Object.entries(ops).map(([key, value]) => [
+						key,
+						typeof value === 'function'
+							? // Async so a refusal rejects, as the SQLite executor's does.
+								async (...args: unknown[]) => {
+									assertLive();
+									return (value as (...a: unknown[]) => unknown)(...args);
+								}
+							: value,
+					]),
+				) as O;
+
+			const tx: Transaction = {
+				collection: <T extends StorableRecordData>(name: string) => {
+					assertLive();
+					return live(rawCollectionFor<T>(name, deferred));
+				},
+				attachments: () => {
+					assertLive();
+					return rawAttachments(deferred);
+				},
+				async abort() {
+					assertLive();
+					settled = true;
+					rollback();
+				},
+			};
+
+			try {
+				const result = await fn(tx);
+				if (!settled) {
+					throwIfFaulted('commit');
+					settled = true;
+					// Committed: the artifacts whose references went may go too.
+					for (const id of pendingArtifactRemovals) {
+						store.artifacts.delete(id);
+					}
+				}
+				return result;
+			} catch (error) {
+				if (!settled) {
+					settled = true;
+					rollback();
+				}
+				throw error;
+			}
 		};
 
 		const handle: DatabaseHandle = {
@@ -234,81 +377,42 @@ export function createMemoryAdapter(options: MemoryAdapterOptions = {}): Storage
 			isEncrypted: store.encrypted,
 			collection: collectionFor,
 
-			async transaction<R>(fn: (tx: Transaction) => Promise<R>): Promise<R> {
+			transaction<R>(fn: (tx: Transaction) => Promise<R>): Promise<R> {
 				assertOpen();
-				// Snapshot-and-restore rather than a write log: simpler to
-				// reason about, and rollback fidelity is what US4 tests.
-				const snapshot = cloneCollections(store);
-				const attachmentSnapshot = new Map(store.attachments);
-				let settled = false;
-
-				const tx: Transaction = {
-					collection: <T extends StorableRecordData>(name: string) => {
-						if (settled) {
-							raise(DiagnosticCodes.TRANSACTION_STATE, {
-								message: 'transaction already settled',
-							});
-						}
-						return collectionFor<T>(name);
-					},
-					async abort() {
-						if (settled) {
-							raise(DiagnosticCodes.TRANSACTION_STATE, {
-								message: 'transaction already settled',
-							});
-						}
-						settled = true;
-						store.collections = snapshot as never;
-						store.attachments = attachmentSnapshot;
-					},
-				};
-
-				try {
-					const result = await fn(tx);
-					if (!settled) {
-						throwIfFaulted('commit');
-						settled = true;
-					}
-					return result;
-				} catch (error) {
-					if (!settled) {
-						settled = true;
-						store.collections = snapshot as never;
-						store.attachments = attachmentSnapshot;
-					}
-					throw error;
-				}
+				return queue.runTransaction(() => runTransaction(fn));
 			},
 
-			async batch(operations: BatchOperation[]): Promise<BatchOutcome> {
+			batch(operations: BatchOperation[]): Promise<BatchOutcome> {
 				assertOpen();
 				assertBatchWithinBudget(operations.length);
-				return handle.transaction(async (tx: Transaction) => {
-					const outcomes = [];
-					for (const operation of operations) {
-						const ops = tx.collection(operation.collection);
-						switch (operation.type) {
-							case 'insert':
-								outcomes.push(await ops.insert(operation.record));
-								break;
-							case 'update':
-								outcomes.push(await ops.update(operation.id, { data: operation.data }));
-								break;
-							case 'upsert':
-								outcomes.push(await ops.upsert(operation.record));
-								break;
-							case 'delete':
-								outcomes.push(await ops.delete(operation.id));
-								break;
-							case 'softDelete':
-								outcomes.push(await ops.softDelete(operation.id));
-								break;
-							default:
-								break;
+				return queue.runTransaction(() =>
+					runTransaction(async (tx: Transaction) => {
+						const outcomes = [];
+						for (const operation of operations) {
+							const ops = tx.collection(operation.collection);
+							switch (operation.type) {
+								case 'insert':
+									outcomes.push(await ops.insert(operation.record));
+									break;
+								case 'update':
+									outcomes.push(await ops.update(operation.id, { data: operation.data }));
+									break;
+								case 'upsert':
+									outcomes.push(await ops.upsert(operation.record));
+									break;
+								case 'delete':
+									outcomes.push(await ops.delete(operation.id));
+									break;
+								case 'softDelete':
+									outcomes.push(await ops.softDelete(operation.id));
+									break;
+								default:
+									break;
+							}
 						}
-					}
-					return { applied: outcomes.length, outcomes };
-				});
+						return { applied: outcomes.length, outcomes };
+					}),
+				);
 			},
 
 			attachments: () => attachments,