@chipmobilesdk/rn-local-db 0.2.0 → 0.3.0

package/src/testing/conformance/records.ts

@@ -1,169 +1,169 @@
-import { DiagnosticCodes } from '../../contract/errors';
-import { isCode } from '../../diagnostics/errors';
-import type { ConformanceContext } from './index';
-
-/** US1: durable CRUD, and the four value conditions staying distinguishable. */
-export function registerRecordConformance(context: ConformanceContext): void {
-	describe('conformance: records', () => {
-		beforeEach(() => context.reset());
-
-		const scope = { kind: 'guest' } as const;
-
-		it('returns exactly what was stored', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			const notes = handle.collection('notes');
-			const data = {
-				title: 'alpha',
-				score: 1.5,
-				nested: { deep: [1, 'two', null, { three: true }] },
-				explicitNull: null,
-			};
-			await notes.insert({ id: 'a', data });
-
-			expect((await notes.get('a')).data).toEqual(data);
-			await handle.close();
-		});
-
-		it('does not mutate the object the caller passed in', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			const data = { title: 'alpha' };
-			await handle.collection('notes').insert({ id: 'a', data });
-			expect(data).toEqual({ title: 'alpha' });
-			await handle.close();
-		});
-
-		it('does not hand back a live reference into the store', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			const notes = handle.collection('notes');
-			await notes.insert({ id: 'a', data: { title: 'alpha' } });
-
-			const first = await notes.get('a');
-			(first.data as { title: string }).title = 'mutated';
-
-			expect((await notes.get('a')).data).toEqual({ title: 'alpha' });
-			await handle.close();
-		});
-
-		it('distinguishes absent record, explicit null, and absent field', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			const notes = handle.collection('notes');
-			await notes.insert({ id: 'null-field', data: { title: null } });
-			await notes.insert({ id: 'absent-field', data: {} });
-
-			const withNull = await notes.get('null-field');
-			expect('title' in withNull.data).toBe(true);
-			expect(withNull.data.title).toBeNull();
-
-			const withAbsent = await notes.get('absent-field');
-			expect('title' in withAbsent.data).toBe(false);
-
-			expect(await notes.find('never-existed')).toBeNull();
-			await handle.close();
-		});
-
-		it('reports a conflict rather than overwriting on insert', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			const notes = handle.collection('notes');
-			await notes.insert({ id: 'a', data: { title: 'first' } });
-
-			let thrown: unknown;
-			try {
-				await notes.insert({ id: 'a', data: { title: 'second' } });
-			} catch (error) {
-				thrown = error;
-			}
-			expect(isCode(thrown, DiagnosticCodes.RECORD_CONFLICT)).toBe(true);
-			expect((await notes.get('a')).data.title).toBe('first');
-			await handle.close();
-		});
-
-		it('reports whether an upsert created or updated', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			const notes = handle.collection('notes');
-			expect((await notes.upsert({ id: 'a', data: { title: 'x' } })).operation).toBe('created');
-			expect((await notes.upsert({ id: 'a', data: { title: 'y' } })).operation).toBe('updated');
-			await handle.close();
-		});
-
-		it('reports record-not-found rather than creating on update', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			let thrown: unknown;
-			try {
-				await handle.collection('notes').update('ghost', { data: { title: 'x' } });
-			} catch (error) {
-				thrown = error;
-			}
-			expect(isCode(thrown, DiagnosticCodes.RECORD_NOT_FOUND)).toBe(true);
-			expect(await handle.collection('notes').find('ghost')).toBeNull();
-			await handle.close();
-		});
-
-		it('makes a hard-deleted record not-found', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			const notes = handle.collection('notes');
-			await notes.insert({ id: 'a', data: { title: 'x' } });
-			await notes.delete('a');
-			expect(await notes.find('a')).toBeNull();
-			await handle.close();
-		});
-
-		it('hides a soft-deleted record by default and restores it', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			const notes = handle.collection('notes');
-			await notes.insert({ id: 'a', data: { title: 'x' } });
-			await notes.softDelete('a');
-
-			expect(await notes.find('a')).toBeNull();
-			expect((await notes.list()).records).toHaveLength(0);
-			expect((await notes.list({ includeSoftDeleted: true })).records).toHaveLength(1);
-
-			await notes.restore('a');
-			expect(await notes.find('a')).not.toBeNull();
-			await handle.close();
-		});
-
-		it('rejects a record over the size budget rather than truncating', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			let thrown: unknown;
-			try {
-				await handle
-					.collection('notes')
-					.insert({ id: 'big', data: { title: 'x'.repeat(300_000) } });
-			} catch (error) {
-				thrown = error;
-			}
-			expect(isCode(thrown, DiagnosticCodes.RECORD_TOO_LARGE)).toBe(true);
-			expect(await handle.collection('notes').find('big')).toBeNull();
-			await handle.close();
-		});
-
-		it('rejects operations on a closed handle', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			await handle.close();
-
-			let thrown: unknown;
-			try {
-				await handle.collection('notes').find('a');
-			} catch (error) {
-				thrown = error;
-			}
-			expect(isCode(thrown, DiagnosticCodes.CLOSED_HANDLE)).toBe(true);
-		});
-
-		it('persists across a close and reopen', async () => {
-			const first = await context.adapter.open(context.configFor(scope));
-			await first.collection('notes').insert({ id: 'a', data: { title: 'kept' } });
-			await first.close();
-
-			const second = await context.adapter.open(context.configFor(scope));
-			expect((await second.collection('notes').get('a')).data.title).toBe('kept');
-			await second.close();
-		});
-
-		it('rejects a collection that was never declared', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			expect(() => handle.collection('nope')).toThrow();
-			await handle.close();
-		});
-	});
-}
+import { DiagnosticCodes } from '../../contract/errors';
+import { isCode } from '../../diagnostics/errors';
+import type { ConformanceContext } from './index';
+
+/** US1: durable CRUD, and the four value conditions staying distinguishable. */
+export function registerRecordConformance(context: ConformanceContext): void {
+	describe('conformance: records', () => {
+		beforeEach(() => context.reset());
+
+		const scope = { kind: 'guest' } as const;
+
+		it('returns exactly what was stored', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			const notes = handle.collection('notes');
+			const data = {
+				title: 'alpha',
+				score: 1.5,
+				nested: { deep: [1, 'two', null, { three: true }] },
+				explicitNull: null,
+			};
+			await notes.insert({ id: 'a', data });
+
+			expect((await notes.get('a')).data).toEqual(data);
+			await handle.close();
+		});
+
+		it('does not mutate the object the caller passed in', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			const data = { title: 'alpha' };
+			await handle.collection('notes').insert({ id: 'a', data });
+			expect(data).toEqual({ title: 'alpha' });
+			await handle.close();
+		});
+
+		it('does not hand back a live reference into the store', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			const notes = handle.collection('notes');
+			await notes.insert({ id: 'a', data: { title: 'alpha' } });
+
+			const first = await notes.get('a');
+			(first.data as { title: string }).title = 'mutated';
+
+			expect((await notes.get('a')).data).toEqual({ title: 'alpha' });
+			await handle.close();
+		});
+
+		it('distinguishes absent record, explicit null, and absent field', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			const notes = handle.collection('notes');
+			await notes.insert({ id: 'null-field', data: { title: null } });
+			await notes.insert({ id: 'absent-field', data: {} });
+
+			const withNull = await notes.get('null-field');
+			expect('title' in withNull.data).toBe(true);
+			expect(withNull.data.title).toBeNull();
+
+			const withAbsent = await notes.get('absent-field');
+			expect('title' in withAbsent.data).toBe(false);
+
+			expect(await notes.find('never-existed')).toBeNull();
+			await handle.close();
+		});
+
+		it('reports a conflict rather than overwriting on insert', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			const notes = handle.collection('notes');
+			await notes.insert({ id: 'a', data: { title: 'first' } });
+
+			let thrown: unknown;
+			try {
+				await notes.insert({ id: 'a', data: { title: 'second' } });
+			} catch (error) {
+				thrown = error;
+			}
+			expect(isCode(thrown, DiagnosticCodes.RECORD_CONFLICT)).toBe(true);
+			expect((await notes.get('a')).data.title).toBe('first');
+			await handle.close();
+		});
+
+		it('reports whether an upsert created or updated', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			const notes = handle.collection('notes');
+			expect((await notes.upsert({ id: 'a', data: { title: 'x' } })).operation).toBe('created');
+			expect((await notes.upsert({ id: 'a', data: { title: 'y' } })).operation).toBe('updated');
+			await handle.close();
+		});
+
+		it('reports record-not-found rather than creating on update', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			let thrown: unknown;
+			try {
+				await handle.collection('notes').update('ghost', { data: { title: 'x' } });
+			} catch (error) {
+				thrown = error;
+			}
+			expect(isCode(thrown, DiagnosticCodes.RECORD_NOT_FOUND)).toBe(true);
+			expect(await handle.collection('notes').find('ghost')).toBeNull();
+			await handle.close();
+		});
+
+		it('makes a hard-deleted record not-found', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			const notes = handle.collection('notes');
+			await notes.insert({ id: 'a', data: { title: 'x' } });
+			await notes.delete('a');
+			expect(await notes.find('a')).toBeNull();
+			await handle.close();
+		});
+
+		it('hides a soft-deleted record by default and restores it', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			const notes = handle.collection('notes');
+			await notes.insert({ id: 'a', data: { title: 'x' } });
+			await notes.softDelete('a');
+
+			expect(await notes.find('a')).toBeNull();
+			expect((await notes.list()).records).toHaveLength(0);
+			expect((await notes.list({ includeSoftDeleted: true })).records).toHaveLength(1);
+
+			await notes.restore('a');
+			expect(await notes.find('a')).not.toBeNull();
+			await handle.close();
+		});
+
+		it('rejects a record over the size budget rather than truncating', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			let thrown: unknown;
+			try {
+				await handle
+					.collection('notes')
+					.insert({ id: 'big', data: { title: 'x'.repeat(300_000) } });
+			} catch (error) {
+				thrown = error;
+			}
+			expect(isCode(thrown, DiagnosticCodes.RECORD_TOO_LARGE)).toBe(true);
+			expect(await handle.collection('notes').find('big')).toBeNull();
+			await handle.close();
+		});
+
+		it('rejects operations on a closed handle', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			await handle.close();
+
+			let thrown: unknown;
+			try {
+				await handle.collection('notes').find('a');
+			} catch (error) {
+				thrown = error;
+			}
+			expect(isCode(thrown, DiagnosticCodes.CLOSED_HANDLE)).toBe(true);
+		});
+
+		it('persists across a close and reopen', async () => {
+			const first = await context.adapter.open(context.configFor(scope));
+			await first.collection('notes').insert({ id: 'a', data: { title: 'kept' } });
+			await first.close();
+
+			const second = await context.adapter.open(context.configFor(scope));
+			expect((await second.collection('notes').get('a')).data.title).toBe('kept');
+			await second.close();
+		});
+
+		it('rejects a collection that was never declared', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			expect(() => handle.collection('nope')).toThrow();
+			await handle.close();
+		});
+	});
+}

package/src/testing/conformance/scopes.ts

@@ -1,88 +1,86 @@
-import type { ScopeDescriptor } from '../../contract/scope';
-import type { ConformanceContext } from './index';
-
-/** US2: scope isolation, proven with unfiltered reads and colliding ids. */
-export function registerScopeConformance(context: ConformanceContext): void {
-	describe('conformance: scopes', () => {
-		beforeEach(() => context.reset());
-
-		const guest: ScopeDescriptor = { kind: 'guest' };
-		const alice: ScopeDescriptor = { kind: 'identity', id: 'alice' };
-		const bob: ScopeDescriptor = { kind: 'identity', id: 'bob' };
-
-		it('returns nothing from another scope, even unfiltered', async () => {
-			const a = await context.adapter.open(context.configFor(alice));
-			await a.collection('notes').insert({ id: 'shared-id', data: { title: 'alice' } });
-			await a.close();
-
-			const b = await context.adapter.open(context.configFor(bob));
-			expect((await b.collection('notes').list()).records).toHaveLength(0);
-			expect(await b.collection('notes').count()).toBe(0);
-			expect(await b.collection('notes').find('shared-id')).toBeNull();
-			await b.close();
-		});
-
-		it('lets the same id exist independently in two scopes', async () => {
-			const a = await context.adapter.open(context.configFor(alice));
-			const b = await context.adapter.open(context.configFor(bob));
-
-			await a.collection('notes').insert({ id: 'same', data: { title: 'alice' } });
-			await b.collection('notes').insert({ id: 'same', data: { title: 'bob' } });
-
-			expect((await a.collection('notes').get('same')).data.title).toBe('alice');
-			expect((await b.collection('notes').get('same')).data.title).toBe('bob');
-			await a.close();
-			await b.close();
-		});
-
-		it('keeps three concurrently open handles independent', async () => {
-			const handles = await Promise.all(
-				[guest, alice, bob].map(scope => context.adapter.open(context.configFor(scope))),
-			);
-
-			await Promise.all(
-				handles.map((handle, index) =>
-					handle.collection('notes').insert({ id: 'x', data: { score: index } }),
-				),
-			);
-
-			for (const [index, handle] of handles.entries()) {
-				expect((await handle.collection('notes').get('x')).data.score).toBe(index);
-				expect(await handle.collection('notes').count()).toBe(1);
-			}
-			await Promise.all(handles.map(handle => handle.close()));
-		});
-
-		it('exposes the scope digest rather than the components', async () => {
-			const handle = await context.adapter.open(context.configFor(alice));
-			expect(handle.scopeKey).toMatch(/^[0-9a-f]{64}$/);
-			expect(handle.scopeKey).not.toContain('alice');
-			await handle.close();
-		});
-
-		it('resolves the same descriptor to the same scope across opens', async () => {
-			const first = await context.adapter.open(context.configFor(alice));
-			const key = first.scopeKey;
-			await first.close();
-
-			const second = await context.adapter.open(
-				context.configFor({ kind: 'identity', id: 'alice' }),
-			);
-			expect(second.scopeKey).toBe(key);
-			await second.close();
-		});
-
-		it('treats a differing component as a different scope', async () => {
-			const plain = await context.adapter.open(context.configFor(alice));
-			const tenanted = await context.adapter.open(
-				context.configFor({ ...alice, tenant: 'acme' }),
-			);
-			expect(tenanted.scopeKey).not.toBe(plain.scopeKey);
-
-			await plain.collection('notes').insert({ id: 'x', data: { title: 'plain' } });
-			expect(await tenanted.collection('notes').find('x')).toBeNull();
-			await plain.close();
-			await tenanted.close();
-		});
-	});
-}
+import type { ScopeDescriptor } from '../../contract/scope';
+import type { ConformanceContext } from './index';
+
+/** US2: scope isolation, proven with unfiltered reads and colliding ids. */
+export function registerScopeConformance(context: ConformanceContext): void {
+	describe('conformance: scopes', () => {
+		beforeEach(() => context.reset());
+
+		const guest: ScopeDescriptor = { kind: 'guest' };
+		const alice: ScopeDescriptor = { kind: 'identity', id: 'alice' };
+		const bob: ScopeDescriptor = { kind: 'identity', id: 'bob' };
+
+		it('returns nothing from another scope, even unfiltered', async () => {
+			const a = await context.adapter.open(context.configFor(alice));
+			await a.collection('notes').insert({ id: 'shared-id', data: { title: 'alice' } });
+			await a.close();
+
+			const b = await context.adapter.open(context.configFor(bob));
+			expect((await b.collection('notes').list()).records).toHaveLength(0);
+			expect(await b.collection('notes').count()).toBe(0);
+			expect(await b.collection('notes').find('shared-id')).toBeNull();
+			await b.close();
+		});
+
+		it('lets the same id exist independently in two scopes', async () => {
+			const a = await context.adapter.open(context.configFor(alice));
+			const b = await context.adapter.open(context.configFor(bob));
+
+			await a.collection('notes').insert({ id: 'same', data: { title: 'alice' } });
+			await b.collection('notes').insert({ id: 'same', data: { title: 'bob' } });
+
+			expect((await a.collection('notes').get('same')).data.title).toBe('alice');
+			expect((await b.collection('notes').get('same')).data.title).toBe('bob');
+			await a.close();
+			await b.close();
+		});
+
+		it('keeps three concurrently open handles independent', async () => {
+			const handles = await Promise.all(
+				[guest, alice, bob].map(scope => context.adapter.open(context.configFor(scope))),
+			);
+
+			await Promise.all(
+				handles.map((handle, index) =>
+					handle.collection('notes').insert({ id: 'x', data: { score: index } }),
+				),
+			);
+
+			for (const [index, handle] of handles.entries()) {
+				expect((await handle.collection('notes').get('x')).data.score).toBe(index);
+				expect(await handle.collection('notes').count()).toBe(1);
+			}
+			await Promise.all(handles.map(handle => handle.close()));
+		});
+
+		it('exposes the scope digest rather than the components', async () => {
+			const handle = await context.adapter.open(context.configFor(alice));
+			expect(handle.scopeKey).toMatch(/^[0-9a-f]{64}$/);
+			expect(handle.scopeKey).not.toContain('alice');
+			await handle.close();
+		});
+
+		it('resolves the same descriptor to the same scope across opens', async () => {
+			const first = await context.adapter.open(context.configFor(alice));
+			const key = first.scopeKey;
+			await first.close();
+
+			const second = await context.adapter.open(
+				context.configFor({ kind: 'identity', id: 'alice' }),
+			);
+			expect(second.scopeKey).toBe(key);
+			await second.close();
+		});
+
+		it('treats a differing component as a different scope', async () => {
+			const plain = await context.adapter.open(context.configFor(alice));
+			const tenanted = await context.adapter.open(context.configFor({ ...alice, tenant: 'acme' }));
+			expect(tenanted.scopeKey).not.toBe(plain.scopeKey);
+
+			await plain.collection('notes').insert({ id: 'x', data: { title: 'plain' } });
+			expect(await tenanted.collection('notes').find('x')).toBeNull();
+			await plain.close();
+			await tenanted.close();
+		});
+	});
+}