@chipmobilesdk/rn-local-db 0.3.0 → 0.4.0

package/src/schema/validate-config.ts

@@ -11,6 +11,7 @@ import { Budgets, type DatabaseConfig } from '../contract/config';
 import { DiagnosticCodes } from '../contract/errors';
 import type { CollectionSchema } from '../contract/schema';
 import { raise } from '../diagnostics/errors';
+import { validateMigrationChain } from '../migration/validate-chain';
 import { validateDescriptor } from '../scope/validate';
 
 const IDENTIFIER = /^[A-Za-z][A-Za-z0-9_]{0,62}$/;
@@ -71,58 +72,6 @@ function validateCollection(collection: CollectionSchema, seen: Set<string>): vo
 	}
 }
 
-function validateMigrations(config: DatabaseConfig): void {
-	const migrations = config.migrations ?? [];
-	if (!Number.isInteger(config.schemaVersion) || config.schemaVersion < 1) {
-		raise(DiagnosticCodes.MIGRATION_CONFIG_INVALID, {
-			message: 'schemaVersion must be a positive integer',
-		});
-	}
-
-	const versions = new Set<number>();
-	for (const migration of migrations) {
-		if (!Number.isInteger(migration.version) || migration.version < 1) {
-			raise(DiagnosticCodes.MIGRATION_CONFIG_INVALID, {
-				message: 'migration version must be a positive integer',
-			});
-		}
-		if (versions.has(migration.version)) {
-			raise(DiagnosticCodes.MIGRATION_CONFIG_INVALID, {
-				message: 'duplicate migration version',
-				detail: { version: migration.version },
-			});
-		}
-		versions.add(migration.version);
-		if (typeof migration.migrate !== 'function') {
-			raise(DiagnosticCodes.MIGRATION_CONFIG_INVALID, {
-				message: 'migration has no migrate function',
-				detail: { version: migration.version },
-			});
-		}
-	}
-
-	// A chain must be able to carry a database from 1 to schemaVersion. A gap
-	// means some upgrading user has no path across it, which is worse than
-	// refusing to open.
-	for (let version = 1; version <= config.schemaVersion; version += 1) {
-		if (!versions.has(version)) {
-			raise(DiagnosticCodes.MIGRATION_CONFIG_INVALID, {
-				message: 'migration chain has a gap',
-				detail: { version },
-			});
-		}
-	}
-
-	for (const version of versions) {
-		if (version > config.schemaVersion) {
-			raise(DiagnosticCodes.MIGRATION_CONFIG_INVALID, {
-				message: 'migration version exceeds the declared schemaVersion',
-				detail: { version },
-			});
-		}
-	}
-}
-
 export function validateConfig(config: DatabaseConfig): void {
 	if (!config || typeof config !== 'object') {
 		configInvalid('database config is required');
@@ -148,7 +97,8 @@ export function validateConfig(config: DatabaseConfig): void {
 		validateCollection(collection, seen);
 	}
 
-	validateMigrations(config);
+	// The one definition of a valid chain, shared with the executor (LDB-12).
+	validateMigrationChain(config);
 
 	if (config.encryption && config.encryption.enabled) {
 		if (typeof config.encryption.keyProvider?.getKey !== 'function') {

package/src/sqlite/batch.ts

@@ -21,8 +21,7 @@ import { raise } from '../diagnostics/errors';
 import { assertBatchWithinBudget, assertRecordWithinBudget } from '../query/budgets';
 import { collectionTable, hasSoftDelete } from '../schema/declare';
 import type { Connection } from './connection';
-import type { SqlValue } from './native';
-import { insertColumns, updateAssignments } from './row-codec';
+import { insertStatement, updateStatement, type Statement } from './statements';
 
 export type BatchContext = {
 	connection: Connection;
@@ -31,42 +30,12 @@ export type BatchContext = {
 	now(): number;
 };
 
-type Command = [string, SqlValue[]];
+type Command = Statement;
 
 function quoted(schema: CollectionSchema): string {
 	return `"${collectionTable(schema.name)}"`;
 }
 
-function insertCommand(
-	schema: CollectionSchema,
-	id: string,
-	data: Parameters<typeof insertColumns>[2],
-	now: number,
-): Command {
-	const { columns, values } = insertColumns(schema, id, data, now);
-	return [
-		`INSERT INTO ${quoted(schema)} (${columns
-			.map(name => `"${name}"`)
-			.join(', ')}) VALUES (${columns.map(() => '?').join(', ')})`,
-		values,
-	];
-}
-
-function updateCommand(
-	schema: CollectionSchema,
-	id: string,
-	data: Parameters<typeof updateAssignments>[1],
-	now: number,
-	restore: boolean,
-): Command {
-	const { columns, values } = updateAssignments(schema, data, now);
-	const assignments = columns.map(name => `"${name}" = ?`);
-	if (restore && hasSoftDelete(schema)) {
-		assignments.push('deleted_at = NULL');
-	}
-	return [`UPDATE ${quoted(schema)} SET ${assignments.join(', ')} WHERE id = ?`, [...values, id]];
-}
-
 /**
  * Where a record stands, as this batch has left it so far. Three states, not
  * two: a soft-deleted row is invisible to reads but still holds its primary
@@ -104,13 +73,13 @@ async function resolveInsert(
 	operation: Extract<BatchOperation, { type: 'insert' }>,
 ): Promise<Resolved> {
 	const { schema, now } = resolver;
-	assertRecordWithinBudget(schema.name, operation.record.data);
+	const payload = assertRecordWithinBudget(schema.name, operation.record.data);
 	if ((await resolver.state(operation.record.id)) !== 'absent') {
 		conflict(schema, operation.record.id);
 	}
 	resolver.stage(operation.record.id, 'live');
 	return {
-		command: insertCommand(schema, operation.record.id, operation.record.data, now),
+		command: insertStatement(schema, operation.record.id, operation.record.data, now, payload),
 		outcome: { operation: 'created', id: operation.record.id },
 	};
 }
@@ -120,12 +89,14 @@ async function resolveUpdate(
 	operation: Extract<BatchOperation, { type: 'update' }>,
 ): Promise<Resolved> {
 	const { schema, now } = resolver;
-	assertRecordWithinBudget(schema.name, operation.data);
+	const payload = assertRecordWithinBudget(schema.name, operation.data);
 	if ((await resolver.state(operation.id)) !== 'live') {
 		missing(schema, operation.id);
 	}
 	return {
-		command: updateCommand(schema, operation.id, operation.data, now, false),
+		command: updateStatement(schema, operation.id, operation.data, now, payload, {
+			restore: false,
+		}),
 		outcome: { operation: 'updated', id: operation.id },
 	};
 }
@@ -135,13 +106,15 @@ async function resolveUpsert(
 	operation: Extract<BatchOperation, { type: 'upsert' }>,
 ): Promise<Resolved> {
 	const { schema, now } = resolver;
-	assertRecordWithinBudget(schema.name, operation.record.data);
+	const payload = assertRecordWithinBudget(schema.name, operation.record.data);
 	const present = (await resolver.state(operation.record.id)) !== 'absent';
 	resolver.stage(operation.record.id, 'live');
 	return {
 		command: present
-			? updateCommand(schema, operation.record.id, operation.record.data, now, true)
-			: insertCommand(schema, operation.record.id, operation.record.data, now),
+			? updateStatement(schema, operation.record.id, operation.record.data, now, payload, {
+					restore: true,
+				})
+			: insertStatement(schema, operation.record.id, operation.record.data, now, payload),
 		outcome: { operation: present ? 'updated' : 'created', id: operation.record.id },
 	};
 }
@@ -209,23 +182,39 @@ export async function runBatch(
 	const outcomes: WriteOutcome[] = [];
 	const overlay = new Map<string, RowState>();
 
+	// What the batch will touch, read once per collection (LDB-08). A batch of a
+	// thousand operations used to make a thousand SELECTs before its one write.
+	// The ids travel as one JSON parameter, so no variable limit applies.
+	const known = new Map<string, RowState>();
+	const idsByCollection = new Map<string, Set<string>>();
+	for (const operation of operations) {
+		const id = 'record' in operation ? operation.record.id : operation.id;
+		const ids = idsByCollection.get(operation.collection) ?? new Set<string>();
+		ids.add(id);
+		idsByCollection.set(operation.collection, ids);
+	}
+	for (const [collection, ids] of idsByCollection) {
+		const schema = context.schemaFor(collection);
+		const result = await context.connection.execute(
+			`SELECT id, deleted_at FROM ${quoted(schema)} WHERE id IN (SELECT value FROM json_each(?))`,
+			[JSON.stringify([...ids])],
+		);
+		for (const row of result.rows) {
+			known.set(
+				`${schema.name}:${String(row.id)}`,
+				row.deleted_at === null || row.deleted_at === undefined ? 'live' : 'softDeleted',
+			);
+		}
+	}
+
 	for (const operation of operations) {
 		const schema = context.schemaFor(operation.collection);
 		const resolver: Resolver = {
 			schema,
 			now: context.now(),
 			async state(id) {
-				const staged = overlay.get(`${schema.name}:${id}`);
-				if (staged !== undefined) {
-					return staged;
-				}
-				const result = await context.connection.execute(
-					`SELECT deleted_at FROM ${quoted(schema)} WHERE id = ?`,
-					[id],
-				);
-				const row = result.rows[0];
-				if (!row) return 'absent';
-				return row.deleted_at === null || row.deleted_at === undefined ? 'live' : 'softDeleted';
+				const key = `${schema.name}:${id}`;
+				return overlay.get(key) ?? known.get(key) ?? 'absent';
 			},
 			stage(id, state) {
 				overlay.set(`${schema.name}:${id}`, state);

package/src/sqlite/connection.ts

@@ -52,8 +52,6 @@ export type Connection = Executor & {
 	readonly encrypted: boolean;
 	transaction<R>(fn: (tx: TransactionExecutor) => Promise<R>): Promise<R>;
 	executeBatch(commands: [string, SqlValue[]?][]): Promise<void>;
-	/** Full-database check, for the diagnostics surface. Never run at open. */
-	integrityCheck(): Promise<boolean>;
 	close(): Promise<void>;
 };
 
@@ -180,13 +178,6 @@ export async function openConnection(options: OpenConnectionOptions): Promise<Co
 			});
 		},
 
-		async integrityCheck() {
-			assertOpen();
-			const result = await connection.execute('PRAGMA quick_check(1)');
-			const first = result.rows[0];
-			return first ? Object.values(first)[0] === 'ok' : false;
-		},
-
 		async close() {
 			if (closed) {
 				return;

package/src/sqlite/row-codec.ts

@@ -176,9 +176,11 @@ export function insertColumns(
 	id: string,
 	data: StorableRecordData,
 	now: number,
+	/** The payload already serialized by the budget check, to avoid a second pass. */
+	payload: string = encodePayload(data),
 ): WriteColumns {
 	const columns = ['id', 'payload'];
-	const values: SqlValue[] = [id, encodePayload(data)];
+	const values: SqlValue[] = [id, payload];
 
 	if (hasTimestamps(schema)) {
 		columns.push('created_at', 'updated_at');
@@ -200,9 +202,10 @@ export function updateAssignments(
 	schema: CollectionSchema,
 	data: StorableRecordData,
 	now: number,
+	payload: string = encodePayload(data),
 ): WriteColumns {
 	const columns = ['payload'];
-	const values: SqlValue[] = [encodePayload(data)];
+	const values: SqlValue[] = [payload];
 
 	if (hasTimestamps(schema)) {
 		columns.push('updated_at');

package/src/sqlite/statements.ts

@@ -0,0 +1,74 @@
+/**
+ * The write statements, built in one place (LDB-12).
+ *
+ * The collection API and the batch each used to assemble their own INSERT and
+ * UPDATE text. Two copies of the same rule is how a batch upsert came to treat
+ * a soft-deleted row differently from a collection upsert.
+ */
+import type { CollectionSchema } from '../contract/schema';
+import { collectionTable, hasSoftDelete } from '../schema/declare';
+import type { SqlValue } from './native';
+import { insertColumns, updateAssignments } from './row-codec';
+
+export type Statement = [sql: string, params: SqlValue[]];
+
+type RecordData = Parameters<typeof insertColumns>[2];
+
+// Built once per table and column list rather than on every write (PERF-10).
+const insertTexts = new Map<string, string>();
+
+function insertText(table: string, columns: readonly string[]): string {
+	const key = `${table}|${columns.join(',')}`;
+	let sql = insertTexts.get(key);
+	if (sql === undefined) {
+		sql = `INSERT INTO "${table}" (${columns.map(name => `"${name}"`).join(', ')}) VALUES (${columns
+			.map(() => '?')
+			.join(', ')})`;
+		insertTexts.set(key, sql);
+	}
+	return sql;
+}
+
+/**
+ * `ignore` leaves a row that already holds the id untouched and reports zero
+ * rows affected, so a conflict is detected without a SELECT beforehand.
+ */
+export function insertStatement(
+	schema: CollectionSchema,
+	id: string,
+	data: RecordData,
+	now: number,
+	payload: string,
+	onConflict: 'fail' | 'ignore' = 'fail',
+): Statement {
+	const { columns, values } = insertColumns(schema, id, data, now, payload);
+	const sql = insertText(collectionTable(schema.name), columns);
+	return [onConflict === 'ignore' ? `${sql} ON CONFLICT(id) DO NOTHING` : sql, values];
+}
+
+export type UpdateOptions = {
+	/** Clear `deleted_at`: an upsert over a soft-deleted record brings it back. */
+	restore?: boolean;
+	/** Match only a record that is not soft-deleted. */
+	liveOnly?: boolean;
+};
+
+export function updateStatement(
+	schema: CollectionSchema,
+	id: string,
+	data: RecordData,
+	now: number,
+	payload: string,
+	options: UpdateOptions = {},
+): Statement {
+	const { columns, values } = updateAssignments(schema, data, now, payload);
+	const assignments = columns.map(name => `"${name}" = ?`);
+	if (options.restore === true && hasSoftDelete(schema)) {
+		assignments.push('deleted_at = NULL');
+	}
+	const live = options.liveOnly === true ? ' AND deleted_at IS NULL' : '';
+	return [
+		`UPDATE "${collectionTable(schema.name)}" SET ${assignments.join(', ')} WHERE id = ?${live}`,
+		[...values, id],
+	];
+}

package/src/testing/index.ts

@@ -8,6 +8,8 @@
 export { createMemoryAdapter, type MemoryAdapterOptions } from './memory-adapter';
 export { memoryConformanceHooks, resetMemoryAdapter, seedRecords } from './memory-adapter/reset';
 export { clearFaults, injectFault, type FaultPoint, type FaultSpec } from './faults';
+/** Makes `openDatabase` and the deletion functions use the given adapter; `null` restores the device one. */
+export { setStorageAdapter } from '../adapter';
 export {
 	runConformanceSuite,
 	type ConformanceContext,

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

@@ -0,0 +1,146 @@
+/**
+ * The in-memory adapter's attachments (FR-091).
+ *
+ * The same surface the SQLite adapter exposes, over the store's maps: written
+ * whole rather than chunked, no filesystem, and a `sourcePath` read through the
+ * `readSourceFile` option a test supplies. Divergences are documented in the
+ * package README.
+ */
+import type { Attachments } from '../../contract/adapter';
+import type {
+	AttachmentInput,
+	AttachmentOwner,
+	AttachmentReference,
+	ByteRange,
+	DeletionOutcome,
+	ReconciliationReport,
+} from '../../contract/attachment';
+import { DiagnosticCodes } from '../../contract/errors';
+import { raise } from '../../diagnostics/errors';
+import { base64ToBytes, bytesToBase64 } from '../../platform/bytes';
+import { assertArtifactWithinBudget } from '../../query/budgets';
+import { assertValidAttachmentId } from '../../platform/location';
+import { throwIfFaulted } from '../faults';
+import type { MemoryScopeStore } from './store';
+import type { MemoryAdapterOptions } from './index';
+
+/** What one artifact removal has to wait for: the transaction that caused it. */
+export interface Deferred {
+	add(id: string): void;
+}
+
+export interface MemoryAttachmentDeps {
+	store: MemoryScopeStore;
+	options: MemoryAdapterOptions;
+	now: () => number;
+	assertOpen: () => void;
+}
+
+export function createMemoryAttachments(deps: MemoryAttachmentDeps) {
+	const { store, options, now, assertOpen } = deps;
+
+	return (deferred?: Deferred): Attachments => ({
+		async write(input: AttachmentInput): Promise<AttachmentReference> {
+			assertOpen();
+			throwIfFaulted('attachmentWrite');
+			assertValidAttachmentId(input.id);
+			let content = input.content;
+			if (content === undefined) {
+				if (!options.readSourceFile) {
+					raise(DiagnosticCodes.STORAGE_ACCESS, {
+						message: 'the memory adapter was not given readSourceFile',
+						detail: { attachmentId: input.id },
+					});
+				}
+				content = await options.readSourceFile(input.sourcePath ?? '');
+			}
+			const bytes = base64ToBytes(content);
+			assertArtifactWithinBudget(input.id, bytes.length);
+			const reference: AttachmentReference = {
+				id: input.id,
+				owner: input.owner,
+				contentType: input.contentType,
+				size: bytes.length,
+				createdAt: now(),
+			};
+			store.artifacts.set(input.id, content);
+			store.attachments.set(input.id, reference);
+			return reference;
+		},
+		async read(id: string, range?: ByteRange): Promise<string> {
+			assertOpen();
+			// No paths here to escape, but an id the device build would refuse
+			// has to be refused here too, or a consumer's passing tests stop
+			// predicting the device (FR-096).
+			assertValidAttachmentId(id);
+			const content = store.artifacts.get(id);
+			if (content === undefined) {
+				raise(DiagnosticCodes.ATTACHMENT_MISSING, {
+					message: 'artifact is missing',
+					detail: { attachmentId: id },
+				});
+			}
+			if (!range) {
+				return content;
+			}
+			const bytes = base64ToBytes(content);
+			return bytesToBase64(bytes.subarray(range.offset, range.offset + range.length));
+		},
+		async availability(id) {
+			assertOpen();
+			const reference = store.attachments.get(id);
+			if (!reference) {
+				return { id, state: 'missing' };
+			}
+			return store.artifacts.has(id)
+				? { id, state: 'available', size: reference.size }
+				: { id, state: 'missing' };
+		},
+		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 {
+				removedRecords: 0,
+				removedArtifacts: removed ? [id] : [],
+				orphanedReferences: [],
+				failedRemovals: [],
+			};
+		},
+		async listFor(owner: AttachmentOwner): Promise<AttachmentReference[]> {
+			assertOpen();
+			return [...store.attachments.values()].filter(
+				reference =>
+					reference.owner?.collection === owner.collection && reference.owner?.id === owner.id,
+			);
+		},
+		async reconcile(reconcileOptions): Promise<ReconciliationReport> {
+			assertOpen();
+			const orphanedArtifacts = [...store.artifacts.keys()].filter(
+				id => !store.attachments.has(id),
+			);
+			const danglingReferences = [...store.attachments.keys()].filter(
+				id => !store.artifacts.has(id),
+			);
+			const removedArtifacts: string[] = [];
+			if (reconcileOptions?.removeOrphans) {
+				for (const id of orphanedArtifacts) {
+					store.artifacts.delete(id);
+					removedArtifacts.push(id);
+				}
+			}
+			return { orphanedArtifacts, danglingReferences, removedArtifacts };
+		},
+	});
+}

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

@@ -6,16 +6,8 @@
  * (research.md R8). Documented divergences are listed in the package README.
  */
 
-import { base64ToBytes, bytesToBase64 } from '../../platform/bytes';
 import { createTransactionQueue } from '../../sqlite/transaction-queue';
-import type {
-	AttachmentInput,
-	AttachmentReference,
-	AttachmentOwner,
-	ByteRange,
-	DeletionOutcome,
-	ReconciliationReport,
-} from '../../contract/attachment';
+import type { DeletionOutcome } from '../../contract/attachment';
 import type { EffectivePosture } from '../../contract/backup';
 import type {
 	DatabaseConfig,
@@ -32,12 +24,11 @@ import type {
 	CollectionOps,
 	Transaction,
 } from '../../contract/transaction';
-import type { Attachments, DatabaseHandle, StorageAdapter } from '../../contract/adapter';
+import type { DatabaseHandle, StorageAdapter } from '../../contract/adapter';
 import { acquireKey } from '../../crypto/key-provider';
 import { instrument } from '../../diagnostics/dev-log';
 import { raise } from '../../diagnostics/errors';
-import { assertValidAttachmentId } from '../../platform/location';
-import { assertBatchWithinBudget, assertArtifactWithinBudget } from '../../query/budgets';
+import { assertBatchWithinBudget } from '../../query/budgets';
 import { validateConfig } from '../../schema/validate-config';
 import { resolveScope } from '../../scope/validate';
 import { runMigrations } from './migrations';
@@ -50,11 +41,18 @@ import {
 	scopeStoreFor,
 	type MemoryScopeStore,
 } from './store';
+import { createMemoryAttachments } from './attachments';
 import { throwIfFaulted } from '../faults';
 
 export type MemoryAdapterOptions = {
 	/** Fixed clock, so timestamp assertions are deterministic. */
 	now?: () => number;
+	/**
+	 * What a `sourcePath` attachment reads, as base64. There is no filesystem
+	 * behind this adapter, so a test that writes attachments by path supplies
+	 * the bytes here; without it such a write is refused with `STORAGE_ACCESS`.
+	 */
+	readSourceFile?: (path: string) => Promise<string> | string;
 };
 
 function schemaIndex(collections: CollectionSchema[]): Map<string, CollectionSchema> {
@@ -189,11 +187,8 @@ export function createMemoryAdapter(options: MemoryAdapterOptions = {}): Storage
 			const ops = instrument(
 				name,
 				'memory',
-				createMemoryCollection<T>({ store, schema, now, assertOpen }) as unknown as Record<
-					string,
-					(...args: never[]) => unknown
-				>,
-			) as unknown as CollectionOps<T>;
+				createMemoryCollection<T>({ store, schema, now, assertOpen }),
+			);
 			if (config.cascadeAttachments !== true) {
 				return ops;
 			}
@@ -215,100 +210,7 @@ export function createMemoryAdapter(options: MemoryAdapterOptions = {}): Storage
 			enforcedBy: 'package',
 		};
 
-		const rawAttachments = (deferred?: Deferred): Attachments => ({
-			async write(input: AttachmentInput): Promise<AttachmentReference> {
-				assertOpen();
-				throwIfFaulted('attachmentWrite');
-				assertValidAttachmentId(input.id);
-				const bytes = base64ToBytes(input.content);
-				assertArtifactWithinBudget(input.id, bytes.length);
-				const reference: AttachmentReference = {
-					id: input.id,
-					owner: input.owner,
-					contentType: input.contentType,
-					size: bytes.length,
-					createdAt: now(),
-				};
-				store.artifacts.set(input.id, input.content);
-				store.attachments.set(input.id, reference);
-				return reference;
-			},
-			async read(id: string, range?: ByteRange): Promise<string> {
-				assertOpen();
-				// No paths here to escape, but an id the device build would refuse
-				// has to be refused here too, or a consumer's passing tests stop
-				// predicting the device (FR-096).
-				assertValidAttachmentId(id);
-				const content = store.artifacts.get(id);
-				if (content === undefined) {
-					raise(DiagnosticCodes.ATTACHMENT_MISSING, {
-						message: 'artifact is missing',
-						detail: { attachmentId: id },
-					});
-				}
-				if (!range) {
-					return content;
-				}
-				const bytes = base64ToBytes(content);
-				return bytesToBase64(bytes.subarray(range.offset, range.offset + range.length));
-			},
-			async availability(id) {
-				assertOpen();
-				const reference = store.attachments.get(id);
-				if (!reference) {
-					return { id, state: 'missing' };
-				}
-				return store.artifacts.has(id)
-					? { id, state: 'available', size: reference.size }
-					: { id, state: 'missing' };
-			},
-			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 {
-					removedRecords: 0,
-					removedArtifacts: removed ? [id] : [],
-					orphanedReferences: [],
-					failedRemovals: [],
-				};
-			},
-			async listFor(owner: AttachmentOwner): Promise<AttachmentReference[]> {
-				assertOpen();
-				return [...store.attachments.values()].filter(
-					reference =>
-						reference.owner?.collection === owner.collection && reference.owner?.id === owner.id,
-				);
-			},
-			async reconcile(reconcileOptions): Promise<ReconciliationReport> {
-				assertOpen();
-				const orphanedArtifacts = [...store.artifacts.keys()].filter(
-					id => !store.attachments.has(id),
-				);
-				const danglingReferences = [...store.attachments.keys()].filter(
-					id => !store.artifacts.has(id),
-				);
-				const removedArtifacts: string[] = [];
-				if (reconcileOptions?.removeOrphans) {
-					for (const id of orphanedArtifacts) {
-						store.artifacts.delete(id);
-						removedArtifacts.push(id);
-					}
-				}
-				return { orphanedArtifacts, danglingReferences, removedArtifacts };
-			},
-		});
+		const rawAttachments = createMemoryAttachments({ store, options, now, assertOpen });
 		const attachments = queued(rawAttachments());
 
 		/**