@chipmobilesdk/rn-local-db 0.2.0 → 0.2.1

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

@@ -1,219 +1,214 @@
-/**
- * Collection operations over the in-memory store.
- *
- * Every semantic decision — filtering, sorting, paging — is delegated to
- * `query/`, the module the SQLite adapter also validates through. Anything
- * decided here instead would be a place the two adapters could drift.
- */
-
-import { DiagnosticCodes } from '../../contract/errors';
-import type { FilterNode, Query, ResultPage } from '../../contract/query';
-import type {
-	RecordInput,
-	StorableRecordData,
-	StoredRecord,
-	WriteOutcome,
-} from '../../contract/record';
-import type { CollectionSchema } from '../../contract/schema';
-import type { CollectionOps } from '../../contract/transaction';
-import { raise } from '../../diagnostics/errors';
-import { throwIfFaulted } from '../../diagnostics/faults';
-import { assertRecordWithinBudget } from '../../query/budgets';
-import { evaluateFilter } from '../../query/filter';
-import { applyCursor, buildPage, resolvePageSize } from '../../query/paginate';
-import { sortRecords, withStableTiebreaker } from '../../query/sort';
-import { validateQuery } from '../../query/validate';
-import { hasSoftDelete, hasTimestamps } from '../../schema/declare';
-import {
-	collectionMap,
-	encodePayload,
-	toStoredRecord,
-	type MemoryScopeStore,
-} from './store';
-
-export type CollectionContext = {
-	store: MemoryScopeStore;
-	schema: CollectionSchema;
-	now: () => number;
-	assertOpen: () => void;
-};
-
-function notFound(collection: string, id: string): never {
-	raise(DiagnosticCodes.RECORD_NOT_FOUND, {
-		message: 'record not found',
-		detail: { collection, recordId: id },
-	});
-}
-
-export function createMemoryCollection<T extends StorableRecordData>(
-	context: CollectionContext,
-): CollectionOps<T> {
-	const { schema } = context;
-	const rows = () => collectionMap(context.store, schema.name);
-
-	const readable = (includeSoftDeleted: boolean): StoredRecord<T>[] => {
-		const out: StoredRecord<T>[] = [];
-		for (const row of rows().values()) {
-			if (!includeSoftDeleted && row.deletedAt != null) {
-				continue;
-			}
-			out.push(toStoredRecord<T>(row));
-		}
-		return out;
-	};
-
-	return {
-		async insert(record: RecordInput<T>): Promise<WriteOutcome> {
-			context.assertOpen();
-			throwIfFaulted('write');
-			assertRecordWithinBudget(schema.name, record.data);
-			if (rows().has(record.id)) {
-				// Overwriting silently is how a caller loses data without ever
-				// seeing a failure.
-				raise(DiagnosticCodes.RECORD_CONFLICT, {
-					message: 'record already exists',
-					detail: { collection: schema.name, recordId: record.id },
-				});
-			}
-			const now = context.now();
-			rows().set(record.id, {
-				id: record.id,
-				payload: encodePayload(record.data),
-				createdAt: hasTimestamps(schema) ? now : undefined,
-				updatedAt: hasTimestamps(schema) ? now : undefined,
-				deletedAt: hasSoftDelete(schema) ? null : undefined,
-			});
-			return { operation: 'created', id: record.id };
-		},
-
-		async update(id, record): Promise<WriteOutcome> {
-			context.assertOpen();
-			throwIfFaulted('write');
-			assertRecordWithinBudget(schema.name, record.data);
-			const existing = rows().get(id);
-			if (!existing || existing.deletedAt != null) {
-				notFound(schema.name, id);
-			}
-			existing.payload = encodePayload(record.data);
-			if (hasTimestamps(schema)) {
-				existing.updatedAt = context.now();
-			}
-			return { operation: 'updated', id };
-		},
-
-		async upsert(record: RecordInput<T>): Promise<WriteOutcome> {
-			context.assertOpen();
-			throwIfFaulted('write');
-			assertRecordWithinBudget(schema.name, record.data);
-			const existing = rows().get(record.id);
-			const now = context.now();
-			if (existing) {
-				existing.payload = encodePayload(record.data);
-				if (hasTimestamps(schema)) {
-					existing.updatedAt = now;
-				}
-				existing.deletedAt = hasSoftDelete(schema) ? null : undefined;
-				return { operation: 'updated', id: record.id };
-			}
-			rows().set(record.id, {
-				id: record.id,
-				payload: encodePayload(record.data),
-				createdAt: hasTimestamps(schema) ? now : undefined,
-				updatedAt: hasTimestamps(schema) ? now : undefined,
-				deletedAt: hasSoftDelete(schema) ? null : undefined,
-			});
-			return { operation: 'created', id: record.id };
-		},
-
-		async get(id: string): Promise<StoredRecord<T>> {
-			context.assertOpen();
-			throwIfFaulted('read');
-			const row = rows().get(id);
-			if (!row || row.deletedAt != null) {
-				notFound(schema.name, id);
-			}
-			return toStoredRecord<T>(row);
-		},
-
-		async find(id: string): Promise<StoredRecord<T> | null> {
-			context.assertOpen();
-			throwIfFaulted('read');
-			const row = rows().get(id);
-			if (!row || row.deletedAt != null) {
-				return null;
-			}
-			return toStoredRecord<T>(row);
-		},
-
-		async delete(id: string): Promise<WriteOutcome> {
-			context.assertOpen();
-			throwIfFaulted('write');
-			if (!rows().delete(id)) {
-				notFound(schema.name, id);
-			}
-			return { operation: 'deleted', id };
-		},
-
-		async softDelete(id: string): Promise<WriteOutcome> {
-			context.assertOpen();
-			throwIfFaulted('write');
-			if (!hasSoftDelete(schema)) {
-				raise(DiagnosticCodes.CONFIG_INVALID, {
-					message: 'collection does not declare soft delete',
-					detail: { collection: schema.name },
-				});
-			}
-			const row = rows().get(id);
-			if (!row || row.deletedAt != null) {
-				notFound(schema.name, id);
-			}
-			row.deletedAt = context.now();
-			return { operation: 'deleted', id };
-		},
-
-		async restore(id: string): Promise<WriteOutcome> {
-			context.assertOpen();
-			throwIfFaulted('write');
-			if (!hasSoftDelete(schema)) {
-				raise(DiagnosticCodes.CONFIG_INVALID, {
-					message: 'collection does not declare soft delete',
-					detail: { collection: schema.name },
-				});
-			}
-			const row = rows().get(id);
-			if (!row || row.deletedAt == null) {
-				notFound(schema.name, id);
-			}
-			row.deletedAt = null;
-			return { operation: 'restored', id };
-		},
-
-		async list(query?: Query): Promise<ResultPage<T>> {
-			context.assertOpen();
-			throwIfFaulted('read');
-			validateQuery(schema, query);
-			const sort = withStableTiebreaker(query?.sort);
-			const size = resolvePageSize(query?.page);
-
-			let matched = readable(query?.includeSoftDeleted === true);
-			if (query?.filter) {
-				matched = matched.filter(record => evaluateFilter(record.data, query.filter!));
-			}
-			const ordered = applyCursor(sortRecords(matched, sort), sort, query?.page?.cursor);
-			return buildPage(ordered.slice(0, size + 1), sort, size);
-		},
-
-		async count(filter?: FilterNode): Promise<number> {
-			context.assertOpen();
-			throwIfFaulted('read');
-			if (filter) {
-				validateQuery(schema, { filter });
-			}
-			const matched = readable(false);
-			if (!filter) {
-				return matched.length;
-			}
-			return matched.filter(record => evaluateFilter(record.data, filter)).length;
-		},
-	};
-}
+/**
+ * Collection operations over the in-memory store.
+ *
+ * Every semantic decision — filtering, sorting, paging — is delegated to
+ * `query/`, the module the SQLite adapter also validates through. Anything
+ * decided here instead would be a place the two adapters could drift.
+ */
+
+import { DiagnosticCodes } from '../../contract/errors';
+import type { FilterNode, Query, ResultPage } from '../../contract/query';
+import type {
+	RecordInput,
+	StorableRecordData,
+	StoredRecord,
+	WriteOutcome,
+} from '../../contract/record';
+import type { CollectionSchema } from '../../contract/schema';
+import type { CollectionOps } from '../../contract/transaction';
+import { raise } from '../../diagnostics/errors';
+import { throwIfFaulted } from '../../diagnostics/faults';
+import { assertRecordWithinBudget } from '../../query/budgets';
+import { evaluateFilter } from '../../query/filter';
+import { applyCursor, buildPage, resolvePageSize } from '../../query/paginate';
+import { sortRecords, withStableTiebreaker } from '../../query/sort';
+import { validateQuery } from '../../query/validate';
+import { hasSoftDelete, hasTimestamps } from '../../schema/declare';
+import { collectionMap, encodePayload, toStoredRecord, type MemoryScopeStore } from './store';
+
+export type CollectionContext = {
+	store: MemoryScopeStore;
+	schema: CollectionSchema;
+	now: () => number;
+	assertOpen: () => void;
+};
+
+function notFound(collection: string, id: string): never {
+	raise(DiagnosticCodes.RECORD_NOT_FOUND, {
+		message: 'record not found',
+		detail: { collection, recordId: id },
+	});
+}
+
+export function createMemoryCollection<T extends StorableRecordData>(
+	context: CollectionContext,
+): CollectionOps<T> {
+	const { schema } = context;
+	const rows = () => collectionMap(context.store, schema.name);
+
+	const readable = (includeSoftDeleted: boolean): StoredRecord<T>[] => {
+		const out: StoredRecord<T>[] = [];
+		for (const row of rows().values()) {
+			if (!includeSoftDeleted && row.deletedAt != null) {
+				continue;
+			}
+			out.push(toStoredRecord<T>(row));
+		}
+		return out;
+	};
+
+	return {
+		async insert(record: RecordInput<T>): Promise<WriteOutcome> {
+			context.assertOpen();
+			throwIfFaulted('write');
+			assertRecordWithinBudget(schema.name, record.data);
+			if (rows().has(record.id)) {
+				// Overwriting silently is how a caller loses data without ever
+				// seeing a failure.
+				raise(DiagnosticCodes.RECORD_CONFLICT, {
+					message: 'record already exists',
+					detail: { collection: schema.name, recordId: record.id },
+				});
+			}
+			const now = context.now();
+			rows().set(record.id, {
+				id: record.id,
+				payload: encodePayload(record.data),
+				createdAt: hasTimestamps(schema) ? now : undefined,
+				updatedAt: hasTimestamps(schema) ? now : undefined,
+				deletedAt: hasSoftDelete(schema) ? null : undefined,
+			});
+			return { operation: 'created', id: record.id };
+		},
+
+		async update(id, record): Promise<WriteOutcome> {
+			context.assertOpen();
+			throwIfFaulted('write');
+			assertRecordWithinBudget(schema.name, record.data);
+			const existing = rows().get(id);
+			if (!existing || existing.deletedAt != null) {
+				notFound(schema.name, id);
+			}
+			existing.payload = encodePayload(record.data);
+			if (hasTimestamps(schema)) {
+				existing.updatedAt = context.now();
+			}
+			return { operation: 'updated', id };
+		},
+
+		async upsert(record: RecordInput<T>): Promise<WriteOutcome> {
+			context.assertOpen();
+			throwIfFaulted('write');
+			assertRecordWithinBudget(schema.name, record.data);
+			const existing = rows().get(record.id);
+			const now = context.now();
+			if (existing) {
+				existing.payload = encodePayload(record.data);
+				if (hasTimestamps(schema)) {
+					existing.updatedAt = now;
+				}
+				existing.deletedAt = hasSoftDelete(schema) ? null : undefined;
+				return { operation: 'updated', id: record.id };
+			}
+			rows().set(record.id, {
+				id: record.id,
+				payload: encodePayload(record.data),
+				createdAt: hasTimestamps(schema) ? now : undefined,
+				updatedAt: hasTimestamps(schema) ? now : undefined,
+				deletedAt: hasSoftDelete(schema) ? null : undefined,
+			});
+			return { operation: 'created', id: record.id };
+		},
+
+		async get(id: string): Promise<StoredRecord<T>> {
+			context.assertOpen();
+			throwIfFaulted('read');
+			const row = rows().get(id);
+			if (!row || row.deletedAt != null) {
+				notFound(schema.name, id);
+			}
+			return toStoredRecord<T>(row);
+		},
+
+		async find(id: string): Promise<StoredRecord<T> | null> {
+			context.assertOpen();
+			throwIfFaulted('read');
+			const row = rows().get(id);
+			if (!row || row.deletedAt != null) {
+				return null;
+			}
+			return toStoredRecord<T>(row);
+		},
+
+		async delete(id: string): Promise<WriteOutcome> {
+			context.assertOpen();
+			throwIfFaulted('write');
+			if (!rows().delete(id)) {
+				notFound(schema.name, id);
+			}
+			return { operation: 'deleted', id };
+		},
+
+		async softDelete(id: string): Promise<WriteOutcome> {
+			context.assertOpen();
+			throwIfFaulted('write');
+			if (!hasSoftDelete(schema)) {
+				raise(DiagnosticCodes.CONFIG_INVALID, {
+					message: 'collection does not declare soft delete',
+					detail: { collection: schema.name },
+				});
+			}
+			const row = rows().get(id);
+			if (!row || row.deletedAt != null) {
+				notFound(schema.name, id);
+			}
+			row.deletedAt = context.now();
+			return { operation: 'deleted', id };
+		},
+
+		async restore(id: string): Promise<WriteOutcome> {
+			context.assertOpen();
+			throwIfFaulted('write');
+			if (!hasSoftDelete(schema)) {
+				raise(DiagnosticCodes.CONFIG_INVALID, {
+					message: 'collection does not declare soft delete',
+					detail: { collection: schema.name },
+				});
+			}
+			const row = rows().get(id);
+			if (!row || row.deletedAt == null) {
+				notFound(schema.name, id);
+			}
+			row.deletedAt = null;
+			return { operation: 'restored', id };
+		},
+
+		async list(query?: Query): Promise<ResultPage<T>> {
+			context.assertOpen();
+			throwIfFaulted('read');
+			validateQuery(schema, query);
+			const sort = withStableTiebreaker(query?.sort);
+			const size = resolvePageSize(query?.page);
+
+			let matched = readable(query?.includeSoftDeleted === true);
+			if (query?.filter) {
+				matched = matched.filter(record => evaluateFilter(record.data, query.filter!));
+			}
+			const ordered = applyCursor(sortRecords(matched, sort), sort, query?.page?.cursor);
+			return buildPage(ordered.slice(0, size + 1), sort, size);
+		},
+
+		async count(filter?: FilterNode): Promise<number> {
+			context.assertOpen();
+			throwIfFaulted('read');
+			if (filter) {
+				validateQuery(schema, { filter });
+			}
+			const matched = readable(false);
+			if (!filter) {
+				return matched.length;
+			}
+			return matched.filter(record => evaluateFilter(record.data, filter)).length;
+		},
+	};
+}