@chipmobilesdk/rn-local-db 0.2.0 → 0.3.0

package/src/testing/conformance/lifecycle.ts

@@ -1,99 +1,99 @@
-import type { ScopeDescriptor } from '../../contract/scope';
-import type { ConformanceContext } from './index';
-
-/** US6: sign-out retains; deletion happens only when asked, and only where asked. */
-export function registerLifecycleConformance(context: ConformanceContext): void {
-	describe('conformance: lifecycle', () => {
-		beforeEach(() => context.reset());
-
-		const alice: ScopeDescriptor = { kind: 'identity', id: 'alice' };
-		const bob: ScopeDescriptor = { kind: 'identity', id: 'bob' };
-
-		it('retains data when a handle is closed without a delete request', async () => {
-			const first = await context.adapter.open(context.configFor(alice));
-			await first.collection('notes').insert({ id: 'a', data: { title: 'kept' } });
-			// Closing the handle is what a sign-out looks like to this package.
-			await first.close();
-
-			const second = await context.adapter.open(context.configFor(alice));
-			expect((await second.collection('notes').get('a')).data.title).toBe('kept');
-			await second.close();
-		});
-
-		it('removes every record in the target scope and nothing else', async () => {
-			const a = await context.adapter.open(context.configFor(alice));
-			await a.collection('notes').insert({ id: 'x', data: { title: 'alice' } });
-			await a.collection('plain').insert({ id: 'y', data: { label: 'alice' } });
-			await a.close();
-
-			const b = await context.adapter.open(context.configFor(bob));
-			await b.collection('notes').insert({ id: 'x', data: { title: 'bob' } });
-			await b.close();
-
-			const outcome = await context.adapter.deleteScopeData(context.scopeTargetFor(alice));
-			expect(outcome.removedRecords).toBe(2);
-
-			const reopenedAlice = await context.adapter.open(context.configFor(alice));
-			expect(await reopenedAlice.collection('notes').count()).toBe(0);
-			expect(await reopenedAlice.collection('plain').count()).toBe(0);
-			await reopenedAlice.close();
-
-			const reopenedBob = await context.adapter.open(context.configFor(bob));
-			expect((await reopenedBob.collection('notes').get('x')).data.title).toBe('bob');
-			await reopenedBob.close();
-		});
-
-		it('reports success for a scope holding no data', async () => {
-			const outcome = await context.adapter.deleteScopeData(
-				context.scopeTargetFor({ kind: 'identity', id: 'never-used' }),
-			);
-			expect(outcome.removedRecords).toBe(0);
-			expect(outcome.failedRemovals).toEqual([]);
-		});
-
-		it('reports what it removed rather than a bare success', async () => {
-			const handle = await context.adapter.open(context.configFor(alice));
-			await handle.collection('notes').insert({ id: 'a', data: { title: 'x' } });
-			await handle.close();
-
-			const outcome = await context.adapter.deleteScopeData(context.scopeTargetFor(alice));
-			expect(outcome).toMatchObject({
-				removedRecords: 1,
-				removedArtifacts: [],
-				orphanedReferences: [],
-				failedRemovals: [],
-			});
-		});
-
-		it('makes the whole database behave as a first install after deleteDatabase', async () => {
-			const handle = await context.adapter.open(context.configFor(alice));
-			await handle.collection('notes').insert({ id: 'a', data: { title: 'x' } });
-			await handle.close();
-
-			await context.adapter.deleteDatabase({ name: 'conformance' });
-
-			const reopened = await context.adapter.open(context.configFor(alice));
-			expect(await reopened.collection('notes').count()).toBe(0);
-			await reopened.close();
-		});
-
-		it('recovers exactly one scope with resetScope', async () => {
-			const a = await context.adapter.open(context.configFor(alice));
-			await a.collection('notes').insert({ id: 'x', data: { title: 'alice' } });
-			await a.close();
-			const b = await context.adapter.open(context.configFor(bob));
-			await b.collection('notes').insert({ id: 'x', data: { title: 'bob' } });
-			await b.close();
-
-			await context.adapter.resetScope(context.scopeTargetFor(alice));
-
-			const reopenedAlice = await context.adapter.open(context.configFor(alice));
-			expect(await reopenedAlice.collection('notes').count()).toBe(0);
-			await reopenedAlice.close();
-
-			const reopenedBob = await context.adapter.open(context.configFor(bob));
-			expect(await reopenedBob.collection('notes').count()).toBe(1);
-			await reopenedBob.close();
-		});
-	});
-}
+import type { ScopeDescriptor } from '../../contract/scope';
+import type { ConformanceContext } from './index';
+
+/** US6: sign-out retains; deletion happens only when asked, and only where asked. */
+export function registerLifecycleConformance(context: ConformanceContext): void {
+	describe('conformance: lifecycle', () => {
+		beforeEach(() => context.reset());
+
+		const alice: ScopeDescriptor = { kind: 'identity', id: 'alice' };
+		const bob: ScopeDescriptor = { kind: 'identity', id: 'bob' };
+
+		it('retains data when a handle is closed without a delete request', async () => {
+			const first = await context.adapter.open(context.configFor(alice));
+			await first.collection('notes').insert({ id: 'a', data: { title: 'kept' } });
+			// Closing the handle is what a sign-out looks like to this package.
+			await first.close();
+
+			const second = await context.adapter.open(context.configFor(alice));
+			expect((await second.collection('notes').get('a')).data.title).toBe('kept');
+			await second.close();
+		});
+
+		it('removes every record in the target scope and nothing else', async () => {
+			const a = await context.adapter.open(context.configFor(alice));
+			await a.collection('notes').insert({ id: 'x', data: { title: 'alice' } });
+			await a.collection('plain').insert({ id: 'y', data: { label: 'alice' } });
+			await a.close();
+
+			const b = await context.adapter.open(context.configFor(bob));
+			await b.collection('notes').insert({ id: 'x', data: { title: 'bob' } });
+			await b.close();
+
+			const outcome = await context.adapter.deleteScopeData(context.scopeTargetFor(alice));
+			expect(outcome.removedRecords).toBe(2);
+
+			const reopenedAlice = await context.adapter.open(context.configFor(alice));
+			expect(await reopenedAlice.collection('notes').count()).toBe(0);
+			expect(await reopenedAlice.collection('plain').count()).toBe(0);
+			await reopenedAlice.close();
+
+			const reopenedBob = await context.adapter.open(context.configFor(bob));
+			expect((await reopenedBob.collection('notes').get('x')).data.title).toBe('bob');
+			await reopenedBob.close();
+		});
+
+		it('reports success for a scope holding no data', async () => {
+			const outcome = await context.adapter.deleteScopeData(
+				context.scopeTargetFor({ kind: 'identity', id: 'never-used' }),
+			);
+			expect(outcome.removedRecords).toBe(0);
+			expect(outcome.failedRemovals).toEqual([]);
+		});
+
+		it('reports what it removed rather than a bare success', async () => {
+			const handle = await context.adapter.open(context.configFor(alice));
+			await handle.collection('notes').insert({ id: 'a', data: { title: 'x' } });
+			await handle.close();
+
+			const outcome = await context.adapter.deleteScopeData(context.scopeTargetFor(alice));
+			expect(outcome).toMatchObject({
+				removedRecords: 1,
+				removedArtifacts: [],
+				orphanedReferences: [],
+				failedRemovals: [],
+			});
+		});
+
+		it('makes the whole database behave as a first install after deleteDatabase', async () => {
+			const handle = await context.adapter.open(context.configFor(alice));
+			await handle.collection('notes').insert({ id: 'a', data: { title: 'x' } });
+			await handle.close();
+
+			await context.adapter.deleteDatabase({ name: 'conformance' });
+
+			const reopened = await context.adapter.open(context.configFor(alice));
+			expect(await reopened.collection('notes').count()).toBe(0);
+			await reopened.close();
+		});
+
+		it('recovers exactly one scope with resetScope', async () => {
+			const a = await context.adapter.open(context.configFor(alice));
+			await a.collection('notes').insert({ id: 'x', data: { title: 'alice' } });
+			await a.close();
+			const b = await context.adapter.open(context.configFor(bob));
+			await b.collection('notes').insert({ id: 'x', data: { title: 'bob' } });
+			await b.close();
+
+			await context.adapter.resetScope(context.scopeTargetFor(alice));
+
+			const reopenedAlice = await context.adapter.open(context.configFor(alice));
+			expect(await reopenedAlice.collection('notes').count()).toBe(0);
+			await reopenedAlice.close();
+
+			const reopenedBob = await context.adapter.open(context.configFor(bob));
+			expect(await reopenedBob.collection('notes').count()).toBe(1);
+			await reopenedBob.close();
+		});
+	});
+}

package/src/testing/conformance/migrations.ts

@@ -1,177 +1,177 @@
-import { DiagnosticCodes } from '../../contract/errors';
-import type { Migration } from '../../contract/migration';
-import { isCode } from '../../diagnostics/errors';
-import type { ConformanceContext } from './index';
-
-/** US5: ordered, once-only migrations that fail loudly. */
-export function registerMigrationConformance(context: ConformanceContext): void {
-	describe('conformance: migrations', () => {
-		beforeEach(() => context.reset());
-
-		const scope = { kind: 'guest' } as const;
-
-		function chain(order: number[], onRun: (version: number) => void): Migration[] {
-			return order.map(version => ({
-				version,
-				migrate: async () => {
-					onRun(version);
-				},
-			}));
-		}
-
-		it('runs pending migrations in ascending order', async () => {
-			const ran: number[] = [];
-			const handle = await context.adapter.open(
-				context.configFor(scope, {
-					schemaVersion: 3,
-					migrations: chain([3, 1, 2], v => ran.push(v)),
-				}),
-			);
-			expect(ran).toEqual([1, 2, 3]);
-			expect(handle.schemaVersion).toBe(3);
-			await handle.close();
-		});
-
-		it('runs each migration at most once across repeated opens', async () => {
-			const ran: number[] = [];
-			const config = context.configFor(scope, {
-				schemaVersion: 2,
-				migrations: chain([1, 2], v => ran.push(v)),
-			});
-
-			for (let i = 0; i < 3; i += 1) {
-				const handle = await context.adapter.open(config);
-				await handle.close();
-			}
-			expect(ran).toEqual([1, 2]);
-		});
-
-		it('returns no handle and keeps the version when a migration fails', async () => {
-			const config = context.configFor(scope, {
-				schemaVersion: 2,
-				migrations: [
-					{ version: 1, migrate: async () => {} },
-					{
-						version: 2,
-						migrate: async () => {
-							throw new Error('boom');
-						},
-					},
-				],
-			});
-
-			let thrown: unknown;
-			try {
-				await context.adapter.open(config);
-			} catch (error) {
-				thrown = error;
-			}
-
-			expect(isCode(thrown, DiagnosticCodes.MIGRATION_FAILED)).toBe(true);
-			expect((thrown as { migration?: unknown }).migration).toEqual({
-				recordedVersion: 1,
-				failingVersion: 2,
-				outcome: 'failed',
-			});
-		});
-
-		it('retries from the same version rather than skipping ahead', async () => {
-			let attempts = 0;
-			const config = context.configFor(scope, {
-				schemaVersion: 1,
-				migrations: [
-					{
-						version: 1,
-						migrate: async () => {
-							attempts += 1;
-							if (attempts < 3) {
-								throw new Error('not yet');
-							}
-						},
-					},
-				],
-			});
-
-			for (let i = 0; i < 2; i += 1) {
-				await expect(context.adapter.open(config)).rejects.toBeDefined();
-			}
-			const handle = await context.adapter.open(config);
-			expect(attempts).toBe(3);
-			expect(handle.schemaVersion).toBe(1);
-			await handle.close();
-		});
-
-		it('alters nothing across repeated failed opens', async () => {
-			const seedConfig = context.configFor(scope, {
-				schemaVersion: 1,
-				migrations: [{ version: 1, migrate: async () => {} }],
-			});
-			const seeded = await context.adapter.open(seedConfig);
-			await seeded.collection('notes').insert({ id: 'keep', data: { title: 'keep' } });
-			await seeded.close();
-
-			const brokenConfig = context.configFor(scope, {
-				schemaVersion: 2,
-				migrations: [
-					{ version: 1, migrate: async () => {} },
-					{
-						version: 2,
-						migrate: async () => {
-							throw new Error('permanently broken');
-						},
-					},
-				],
-			});
-
-			for (let i = 0; i < 10; i += 1) {
-				await expect(context.adapter.open(brokenConfig)).rejects.toBeDefined();
-			}
-
-			const recovered = await context.adapter.open(seedConfig);
-			expect((await recovered.collection('notes').get('keep')).data.title).toBe('keep');
-			await recovered.close();
-		});
-
-		it('reports a downgrade rather than opening or discarding', async () => {
-			const newer = await context.adapter.open(
-				context.configFor(scope, {
-					schemaVersion: 3,
-					migrations: chain([1, 2, 3], () => {}),
-				}),
-			);
-			await newer.close();
-
-			let thrown: unknown;
-			try {
-				await context.adapter.open(
-					context.configFor(scope, {
-						schemaVersion: 1,
-						migrations: chain([1], () => {}),
-					}),
-				);
-			} catch (error) {
-				thrown = error;
-			}
-			expect(isCode(thrown, DiagnosticCodes.SCHEMA_DOWNGRADE)).toBe(true);
-		});
-
-		it('migrates a scope created after the migration shipped', async () => {
-			const ran: number[] = [];
-			const config = (id: string) =>
-				context.configFor(
-					{ kind: 'identity', id },
-					{ schemaVersion: 2, migrations: chain([1, 2], v => ran.push(v)) },
-				);
-
-			const first = await context.adapter.open(config('alice'));
-			await first.close();
-			ran.length = 0;
-
-			// A brand-new scope must not be assumed already current.
-			const second = await context.adapter.open(config('bob'));
-			expect(ran).toEqual([1, 2]);
-			expect(second.schemaVersion).toBe(2);
-			await second.close();
-		});
-	});
-}
+import { DiagnosticCodes } from '../../contract/errors';
+import type { Migration } from '../../contract/migration';
+import { isCode } from '../../diagnostics/errors';
+import type { ConformanceContext } from './index';
+
+/** US5: ordered, once-only migrations that fail loudly. */
+export function registerMigrationConformance(context: ConformanceContext): void {
+	describe('conformance: migrations', () => {
+		beforeEach(() => context.reset());
+
+		const scope = { kind: 'guest' } as const;
+
+		function chain(order: number[], onRun: (version: number) => void): Migration[] {
+			return order.map(version => ({
+				version,
+				migrate: async () => {
+					onRun(version);
+				},
+			}));
+		}
+
+		it('runs pending migrations in ascending order', async () => {
+			const ran: number[] = [];
+			const handle = await context.adapter.open(
+				context.configFor(scope, {
+					schemaVersion: 3,
+					migrations: chain([3, 1, 2], v => ran.push(v)),
+				}),
+			);
+			expect(ran).toEqual([1, 2, 3]);
+			expect(handle.schemaVersion).toBe(3);
+			await handle.close();
+		});
+
+		it('runs each migration at most once across repeated opens', async () => {
+			const ran: number[] = [];
+			const config = context.configFor(scope, {
+				schemaVersion: 2,
+				migrations: chain([1, 2], v => ran.push(v)),
+			});
+
+			for (let i = 0; i < 3; i += 1) {
+				const handle = await context.adapter.open(config);
+				await handle.close();
+			}
+			expect(ran).toEqual([1, 2]);
+		});
+
+		it('returns no handle and keeps the version when a migration fails', async () => {
+			const config = context.configFor(scope, {
+				schemaVersion: 2,
+				migrations: [
+					{ version: 1, migrate: async () => {} },
+					{
+						version: 2,
+						migrate: async () => {
+							throw new Error('boom');
+						},
+					},
+				],
+			});
+
+			let thrown: unknown;
+			try {
+				await context.adapter.open(config);
+			} catch (error) {
+				thrown = error;
+			}
+
+			expect(isCode(thrown, DiagnosticCodes.MIGRATION_FAILED)).toBe(true);
+			expect((thrown as { migration?: unknown }).migration).toEqual({
+				recordedVersion: 1,
+				failingVersion: 2,
+				outcome: 'failed',
+			});
+		});
+
+		it('retries from the same version rather than skipping ahead', async () => {
+			let attempts = 0;
+			const config = context.configFor(scope, {
+				schemaVersion: 1,
+				migrations: [
+					{
+						version: 1,
+						migrate: async () => {
+							attempts += 1;
+							if (attempts < 3) {
+								throw new Error('not yet');
+							}
+						},
+					},
+				],
+			});
+
+			for (let i = 0; i < 2; i += 1) {
+				await expect(context.adapter.open(config)).rejects.toBeDefined();
+			}
+			const handle = await context.adapter.open(config);
+			expect(attempts).toBe(3);
+			expect(handle.schemaVersion).toBe(1);
+			await handle.close();
+		});
+
+		it('alters nothing across repeated failed opens', async () => {
+			const seedConfig = context.configFor(scope, {
+				schemaVersion: 1,
+				migrations: [{ version: 1, migrate: async () => {} }],
+			});
+			const seeded = await context.adapter.open(seedConfig);
+			await seeded.collection('notes').insert({ id: 'keep', data: { title: 'keep' } });
+			await seeded.close();
+
+			const brokenConfig = context.configFor(scope, {
+				schemaVersion: 2,
+				migrations: [
+					{ version: 1, migrate: async () => {} },
+					{
+						version: 2,
+						migrate: async () => {
+							throw new Error('permanently broken');
+						},
+					},
+				],
+			});
+
+			for (let i = 0; i < 10; i += 1) {
+				await expect(context.adapter.open(brokenConfig)).rejects.toBeDefined();
+			}
+
+			const recovered = await context.adapter.open(seedConfig);
+			expect((await recovered.collection('notes').get('keep')).data.title).toBe('keep');
+			await recovered.close();
+		});
+
+		it('reports a downgrade rather than opening or discarding', async () => {
+			const newer = await context.adapter.open(
+				context.configFor(scope, {
+					schemaVersion: 3,
+					migrations: chain([1, 2, 3], () => {}),
+				}),
+			);
+			await newer.close();
+
+			let thrown: unknown;
+			try {
+				await context.adapter.open(
+					context.configFor(scope, {
+						schemaVersion: 1,
+						migrations: chain([1], () => {}),
+					}),
+				);
+			} catch (error) {
+				thrown = error;
+			}
+			expect(isCode(thrown, DiagnosticCodes.SCHEMA_DOWNGRADE)).toBe(true);
+		});
+
+		it('migrates a scope created after the migration shipped', async () => {
+			const ran: number[] = [];
+			const config = (id: string) =>
+				context.configFor(
+					{ kind: 'identity', id },
+					{ schemaVersion: 2, migrations: chain([1, 2], v => ran.push(v)) },
+				);
+
+			const first = await context.adapter.open(config('alice'));
+			await first.close();
+			ran.length = 0;
+
+			// A brand-new scope must not be assumed already current.
+			const second = await context.adapter.open(config('bob'));
+			expect(ran).toEqual([1, 2]);
+			expect(second.schemaVersion).toBe(2);
+			await second.close();
+		});
+	});
+}