@chipmobilesdk/rn-local-db 0.1.2 → 0.2.1

package/src/sqlite/values.ts

@@ -1,24 +1,24 @@
-/**
- * Reading values back out of a result row.
- *
- * The engine hands back `unknown` per column, and every read site would
- * otherwise repeat the same `String(...)` / `Number(...)` coercion with a
- * slightly different null check. One place to do it means one place where the
- * "NULL means absent, not empty string" rule is decided.
- */
-
-export function text(value: unknown): string {
-	return typeof value === 'string' ? value : String(value as string | number | boolean);
-}
-
-export function num(value: unknown): number {
-	return typeof value === 'number' ? value : Number(value as string | number);
-}
-
-export function maybeText(value: unknown): string | null {
-	return value == null ? null : text(value);
-}
-
-export function maybeNum(value: unknown): number | null {
-	return value == null ? null : num(value);
-}
+/**
+ * Reading values back out of a result row.
+ *
+ * The engine hands back `unknown` per column, and every read site would
+ * otherwise repeat the same `String(...)` / `Number(...)` coercion with a
+ * slightly different null check. One place to do it means one place where the
+ * "NULL means absent, not empty string" rule is decided.
+ */
+
+export function text(value: unknown): string {
+	return typeof value === 'string' ? value : String(value as string | number | boolean);
+}
+
+export function num(value: unknown): number {
+	return typeof value === 'number' ? value : Number(value as string | number);
+}
+
+export function maybeText(value: unknown): string | null {
+	return value == null ? null : text(value);
+}
+
+export function maybeNum(value: unknown): number | null {
+	return value == null ? null : num(value);
+}

package/src/testing/conformance/attachments.ts

@@ -1,136 +1,138 @@
-import { DiagnosticCodes } from '../../contract/errors';
-import { isCode } from '../../diagnostics/errors';
-import type { ConformanceContext } from './index';
-
-/** US7: artifacts the package owns, and the reconciliation that keeps them honest. */
-export function registerAttachmentConformance(context: ConformanceContext): void {
-	describe('conformance: attachments', () => {
-		beforeEach(() => context.reset());
-
-		const scope = { kind: 'guest' } as const;
-		const content = Buffer.from('hello attachment', 'utf8').toString('base64');
-
-		it('stores a reference alongside the artifact', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			const attachments = handle.attachments();
-			const reference = await attachments.write({
-				id: 'a1',
-				owner: { collection: 'notes', id: 'n1' },
-				contentType: 'text/plain',
-				content,
-			});
-
-			expect(reference.size).toBe(Buffer.from(content, 'base64').length);
-			expect(await attachments.read('a1')).toBe(content);
-			expect((await attachments.availability('a1')).state).toBe('available');
-			await handle.close();
-		});
-
-		it('reads a byte range without materialising the whole artifact', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			const attachments = handle.attachments();
-			await attachments.write({ id: 'a1', contentType: 'text/plain', content });
-
-			const slice = await attachments.read('a1', { offset: 0, length: 5 });
-			expect(Buffer.from(slice, 'base64').toString('utf8')).toBe('hello');
-			await handle.close();
-		});
-
-		it('lists the attachments belonging to a record', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			const attachments = handle.attachments();
-			await attachments.write({
-				id: 'a1',
-				owner: { collection: 'notes', id: 'n1' },
-				contentType: 'text/plain',
-				content,
-			});
-			await attachments.write({ id: 'a2', contentType: 'text/plain', content });
-
-			const owned = await attachments.listFor({ collection: 'notes', id: 'n1' });
-			expect(owned.map(r => r.id)).toEqual(['a1']);
-			await handle.close();
-		});
-
-		it('reports a missing artifact without making the record unreadable', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			await handle.collection('notes').insert({ id: 'n1', data: { title: 'has media' } });
-			const attachments = handle.attachments();
-			await attachments.write({
-				id: 'a1',
-				owner: { collection: 'notes', id: 'n1' },
-				contentType: 'text/plain',
-				content,
-			});
-
-			// Remove the artifact behind the package's back.
-			await context.removeArtifactBehindTheScenes(handle.scopeKey, 'a1');
-
-			expect((await attachments.availability('a1')).state).toBe('missing');
-			expect((await handle.collection('notes').get('n1')).data.title).toBe('has media');
-			await handle.close();
-		});
-
-		it('finds an orphaned artifact and a dangling reference', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			const attachments = handle.attachments();
-			await attachments.write({ id: 'a1', contentType: 'text/plain', content });
-			await context.removeReferenceBehindTheScenes(handle.scopeKey, 'a1');
-
-			await attachments.write({ id: 'a2', contentType: 'text/plain', content });
-			await context.removeArtifactBehindTheScenes(handle.scopeKey, 'a2');
-
-			const report = await attachments.reconcile();
-			expect(report.orphanedArtifacts).toEqual(['a1']);
-			expect(report.danglingReferences).toEqual(['a2']);
-
-			const removed = await attachments.reconcile({ removeOrphans: true });
-			expect(removed.removedArtifacts).toEqual(['a1']);
-			expect((await attachments.reconcile()).orphanedArtifacts).toEqual([]);
-			await handle.close();
-		});
-
-		it('rolls a reference back with its transaction', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			try {
-				await handle.transaction(async tx => {
-					await tx.collection('notes').insert({ id: 'n1', data: { title: 'x' } });
-					await handle.attachments().write({ id: 'a1', contentType: 'text/plain', content });
-					throw new Error('injected');
-				});
-			} catch {
-				// Expected.
-			}
-
-			expect(await handle.collection('notes').find('n1')).toBeNull();
-			// The reference is gone; the artifact on disk is not, which is
-			// exactly why reconciliation exists.
-			const report = await handle.attachments().reconcile();
-			expect(report.orphanedArtifacts).toEqual(['a1']);
-			await handle.close();
-		});
-
-		it('rejects an artifact over the size budget', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			const huge = Buffer.alloc(101 * 1024 * 1024).toString('base64');
-
-			let thrown: unknown;
-			try {
-				await handle.attachments().write({ id: 'big', contentType: 'application/octet-stream', content: huge });
-			} catch (error) {
-				thrown = error;
-			}
-			expect(isCode(thrown, DiagnosticCodes.ATTACHMENT_WRITE_FAILED)).toBe(true);
-			await handle.close();
-		});
-
-		it('removes artifacts when the scope is deleted', async () => {
-			const handle = await context.adapter.open(context.configFor(scope));
-			await handle.attachments().write({ id: 'a1', contentType: 'text/plain', content });
-			await handle.close();
-
-			const outcome = await context.adapter.deleteScopeData(context.scopeTargetFor(scope));
-			expect(outcome.removedArtifacts).toContain('a1');
-		});
-	});
-}
+import { DiagnosticCodes } from '../../contract/errors';
+import { isCode } from '../../diagnostics/errors';
+import type { ConformanceContext } from './index';
+
+/** US7: artifacts the package owns, and the reconciliation that keeps them honest. */
+export function registerAttachmentConformance(context: ConformanceContext): void {
+	describe('conformance: attachments', () => {
+		beforeEach(() => context.reset());
+
+		const scope = { kind: 'guest' } as const;
+		const content = Buffer.from('hello attachment', 'utf8').toString('base64');
+
+		it('stores a reference alongside the artifact', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			const attachments = handle.attachments();
+			const reference = await attachments.write({
+				id: 'a1',
+				owner: { collection: 'notes', id: 'n1' },
+				contentType: 'text/plain',
+				content,
+			});
+
+			expect(reference.size).toBe(Buffer.from(content, 'base64').length);
+			expect(await attachments.read('a1')).toBe(content);
+			expect((await attachments.availability('a1')).state).toBe('available');
+			await handle.close();
+		});
+
+		it('reads a byte range without materialising the whole artifact', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			const attachments = handle.attachments();
+			await attachments.write({ id: 'a1', contentType: 'text/plain', content });
+
+			const slice = await attachments.read('a1', { offset: 0, length: 5 });
+			expect(Buffer.from(slice, 'base64').toString('utf8')).toBe('hello');
+			await handle.close();
+		});
+
+		it('lists the attachments belonging to a record', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			const attachments = handle.attachments();
+			await attachments.write({
+				id: 'a1',
+				owner: { collection: 'notes', id: 'n1' },
+				contentType: 'text/plain',
+				content,
+			});
+			await attachments.write({ id: 'a2', contentType: 'text/plain', content });
+
+			const owned = await attachments.listFor({ collection: 'notes', id: 'n1' });
+			expect(owned.map(r => r.id)).toEqual(['a1']);
+			await handle.close();
+		});
+
+		it('reports a missing artifact without making the record unreadable', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			await handle.collection('notes').insert({ id: 'n1', data: { title: 'has media' } });
+			const attachments = handle.attachments();
+			await attachments.write({
+				id: 'a1',
+				owner: { collection: 'notes', id: 'n1' },
+				contentType: 'text/plain',
+				content,
+			});
+
+			// Remove the artifact behind the package's back.
+			await context.removeArtifactBehindTheScenes(handle.scopeKey, 'a1');
+
+			expect((await attachments.availability('a1')).state).toBe('missing');
+			expect((await handle.collection('notes').get('n1')).data.title).toBe('has media');
+			await handle.close();
+		});
+
+		it('finds an orphaned artifact and a dangling reference', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			const attachments = handle.attachments();
+			await attachments.write({ id: 'a1', contentType: 'text/plain', content });
+			await context.removeReferenceBehindTheScenes(handle.scopeKey, 'a1');
+
+			await attachments.write({ id: 'a2', contentType: 'text/plain', content });
+			await context.removeArtifactBehindTheScenes(handle.scopeKey, 'a2');
+
+			const report = await attachments.reconcile();
+			expect(report.orphanedArtifacts).toEqual(['a1']);
+			expect(report.danglingReferences).toEqual(['a2']);
+
+			const removed = await attachments.reconcile({ removeOrphans: true });
+			expect(removed.removedArtifacts).toEqual(['a1']);
+			expect((await attachments.reconcile()).orphanedArtifacts).toEqual([]);
+			await handle.close();
+		});
+
+		it('rolls a reference back with its transaction', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			try {
+				await handle.transaction(async tx => {
+					await tx.collection('notes').insert({ id: 'n1', data: { title: 'x' } });
+					await tx.attachments().write({ id: 'a1', contentType: 'text/plain', content });
+					throw new Error('injected');
+				});
+			} catch {
+				// Expected.
+			}
+
+			expect(await handle.collection('notes').find('n1')).toBeNull();
+			// The reference is gone; the artifact on disk is not, which is
+			// exactly why reconciliation exists.
+			const report = await handle.attachments().reconcile();
+			expect(report.orphanedArtifacts).toEqual(['a1']);
+			await handle.close();
+		});
+
+		it('rejects an artifact over the size budget', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			const huge = Buffer.alloc(101 * 1024 * 1024).toString('base64');
+
+			let thrown: unknown;
+			try {
+				await handle
+					.attachments()
+					.write({ id: 'big', contentType: 'application/octet-stream', content: huge });
+			} catch (error) {
+				thrown = error;
+			}
+			expect(isCode(thrown, DiagnosticCodes.ATTACHMENT_WRITE_FAILED)).toBe(true);
+			await handle.close();
+		});
+
+		it('removes artifacts when the scope is deleted', async () => {
+			const handle = await context.adapter.open(context.configFor(scope));
+			await handle.attachments().write({ id: 'a1', contentType: 'text/plain', content });
+			await handle.close();
+
+			const outcome = await context.adapter.deleteScopeData(context.scopeTargetFor(scope));
+			expect(outcome.removedArtifacts).toContain('a1');
+		});
+	});
+}

package/src/testing/conformance/encryption.ts

@@ -1,150 +1,150 @@
-import { DiagnosticCodes } from '../../contract/errors';
-import type { KeyProvider } from '../../contract/encryption';
-import { isCode } from '../../diagnostics/errors';
-import type { ConformanceContext } from './index';
-
-/** US10: opt-in encryption, and failures that stay apart from each other. */
-export function registerEncryptionConformance(context: ConformanceContext): void {
-	describe('conformance: encryption', () => {
-		beforeEach(() => context.reset());
-
-		const scope = { kind: 'identity', id: 'encrypted' } as const;
-		const keyProvider: KeyProvider = { getKey: async () => 'a-correct-key-32-bytes-long-value' };
-
-		const encrypted = { enabled: true as const, keyProvider };
-
-		it('reports its own posture', async () => {
-			const handle = await context.adapter.open(
-				context.configFor(scope, { encryption: encrypted }),
-			);
-			expect(handle.isEncrypted).toBe(true);
-			await handle.close();
-
-			const plain = await context.adapter.open(
-				context.configFor({ kind: 'identity', id: 'plain' }, { encryption: undefined }),
-			);
-			expect(plain.isEncrypted).toBe(false);
-			await plain.close();
-		});
-
-		it('stores and returns records unchanged under encryption', async () => {
-			const handle = await context.adapter.open(
-				context.configFor(scope, { encryption: encrypted }),
-			);
-			const data = { title: 'secret', score: 1, nested: { deep: [1, null, true] } };
-			await handle.collection('notes').insert({ id: 'a', data });
-			expect((await handle.collection('notes').get('a')).data).toEqual(data);
-			await handle.close();
-
-			const reopened = await context.adapter.open(
-				context.configFor(scope, { encryption: encrypted }),
-			);
-			expect((await reopened.collection('notes').get('a')).data).toEqual(data);
-			await reopened.close();
-		});
-
-		it('round-trips an artifact under encryption, including a byte range', async () => {
-			const handle = await context.adapter.open(
-				context.configFor(scope, { encryption: encrypted }),
-			);
-			const content = Buffer.from('hello encrypted attachment', 'utf8').toString('base64');
-			await handle.attachments().write({ id: 'a1', contentType: 'text/plain', content });
-
-			expect(await handle.attachments().read('a1')).toBe(content);
-			const slice = await handle.attachments().read('a1', { offset: 6, length: 9 });
-			expect(Buffer.from(slice, 'base64').toString('utf8')).toBe('encrypted');
-			expect((await handle.attachments().availability('a1')).state).toBe('available');
-			await handle.close();
-		});
-
-		it('reports a key-provider failure separately from an invalid key', async () => {
-			let thrown: unknown;
-			try {
-				await context.adapter.open(
-					context.configFor(scope, {
-						encryption: {
-							enabled: true,
-							keyProvider: {
-								getKey: async () => {
-									throw new Error('device is locked');
-								},
-							},
-						},
-					}),
-				);
-			} catch (error) {
-				thrown = error;
-			}
-			expect(isCode(thrown, DiagnosticCodes.KEY_PROVIDER_FAILED)).toBe(true);
-
-			let empty: unknown;
-			try {
-				await context.adapter.open(
-					context.configFor(scope, {
-						encryption: { enabled: true, keyProvider: { getKey: async () => '' } },
-					}),
-				);
-			} catch (error) {
-				empty = error;
-			}
-			expect(isCode(empty, DiagnosticCodes.KEY_INVALID)).toBe(true);
-		});
-
-		it('reports a posture mismatch rather than opening or converting', async () => {
-			const plain = await context.adapter.open(context.configFor(scope));
-			await plain.collection('notes').insert({ id: 'a', data: { title: 'plaintext' } });
-			await plain.close();
-
-			let thrown: unknown;
-			try {
-				await context.adapter.open(context.configFor(scope, { encryption: encrypted }));
-			} catch (error) {
-				thrown = error;
-			}
-			expect(isCode(thrown, DiagnosticCodes.ENCRYPTION_MISMATCH)).toBe(true);
-
-			// Nothing was converted, truncated, or discarded.
-			const reopened = await context.adapter.open(context.configFor(scope));
-			expect((await reopened.collection('notes').get('a')).data.title).toBe('plaintext');
-			await reopened.close();
-		});
-
-		it('gives the key provider the scope, so an app can key per identity', async () => {
-			const seen: string[] = [];
-			const recording: KeyProvider = {
-				getKey: async resolved => {
-					seen.push(resolved.key);
-					return `key-for-${resolved.key}`;
-				},
-			};
-
-			for (const id of ['alice', 'bob']) {
-				const handle = await context.adapter.open(
-					context.configFor(
-						{ kind: 'identity', id },
-						{ encryption: { enabled: true, keyProvider: recording } },
-					),
-				);
-				await handle.close();
-			}
-
-			expect(seen).toHaveLength(2);
-			expect(new Set(seen).size).toBe(2);
-			for (const key of seen) {
-				expect(key).toMatch(/^[0-9a-f]{64}$/);
-			}
-		});
-
-		it('keeps an encrypted scope isolated from an unencrypted sibling', async () => {
-			const secure = await context.adapter.open(
-				context.configFor({ kind: 'identity', id: 'secure' }, { encryption: encrypted }),
-			);
-			await secure.collection('notes').insert({ id: 'shared', data: { title: 'secure' } });
-			await secure.close();
-
-			const open = await context.adapter.open(context.configFor({ kind: 'identity', id: 'open' }));
-			expect(await open.collection('notes').find('shared')).toBeNull();
-			await open.close();
-		});
-	});
-}
+import { DiagnosticCodes } from '../../contract/errors';
+import type { KeyProvider } from '../../contract/encryption';
+import { isCode } from '../../diagnostics/errors';
+import type { ConformanceContext } from './index';
+
+/** US10: opt-in encryption, and failures that stay apart from each other. */
+export function registerEncryptionConformance(context: ConformanceContext): void {
+	describe('conformance: encryption', () => {
+		beforeEach(() => context.reset());
+
+		const scope = { kind: 'identity', id: 'encrypted' } as const;
+		const keyProvider: KeyProvider = { getKey: async () => 'a-correct-key-32-bytes-long-value' };
+
+		const encrypted = { enabled: true as const, keyProvider };
+
+		it('reports its own posture', async () => {
+			const handle = await context.adapter.open(
+				context.configFor(scope, { encryption: encrypted }),
+			);
+			expect(handle.isEncrypted).toBe(true);
+			await handle.close();
+
+			const plain = await context.adapter.open(
+				context.configFor({ kind: 'identity', id: 'plain' }, { encryption: undefined }),
+			);
+			expect(plain.isEncrypted).toBe(false);
+			await plain.close();
+		});
+
+		it('stores and returns records unchanged under encryption', async () => {
+			const handle = await context.adapter.open(
+				context.configFor(scope, { encryption: encrypted }),
+			);
+			const data = { title: 'secret', score: 1, nested: { deep: [1, null, true] } };
+			await handle.collection('notes').insert({ id: 'a', data });
+			expect((await handle.collection('notes').get('a')).data).toEqual(data);
+			await handle.close();
+
+			const reopened = await context.adapter.open(
+				context.configFor(scope, { encryption: encrypted }),
+			);
+			expect((await reopened.collection('notes').get('a')).data).toEqual(data);
+			await reopened.close();
+		});
+
+		it('round-trips an artifact under encryption, including a byte range', async () => {
+			const handle = await context.adapter.open(
+				context.configFor(scope, { encryption: encrypted }),
+			);
+			const content = Buffer.from('hello encrypted attachment', 'utf8').toString('base64');
+			await handle.attachments().write({ id: 'a1', contentType: 'text/plain', content });
+
+			expect(await handle.attachments().read('a1')).toBe(content);
+			const slice = await handle.attachments().read('a1', { offset: 6, length: 9 });
+			expect(Buffer.from(slice, 'base64').toString('utf8')).toBe('encrypted');
+			expect((await handle.attachments().availability('a1')).state).toBe('available');
+			await handle.close();
+		});
+
+		it('reports a key-provider failure separately from an invalid key', async () => {
+			let thrown: unknown;
+			try {
+				await context.adapter.open(
+					context.configFor(scope, {
+						encryption: {
+							enabled: true,
+							keyProvider: {
+								getKey: async () => {
+									throw new Error('device is locked');
+								},
+							},
+						},
+					}),
+				);
+			} catch (error) {
+				thrown = error;
+			}
+			expect(isCode(thrown, DiagnosticCodes.KEY_PROVIDER_FAILED)).toBe(true);
+
+			let empty: unknown;
+			try {
+				await context.adapter.open(
+					context.configFor(scope, {
+						encryption: { enabled: true, keyProvider: { getKey: async () => '' } },
+					}),
+				);
+			} catch (error) {
+				empty = error;
+			}
+			expect(isCode(empty, DiagnosticCodes.KEY_INVALID)).toBe(true);
+		});
+
+		it('reports a posture mismatch rather than opening or converting', async () => {
+			const plain = await context.adapter.open(context.configFor(scope));
+			await plain.collection('notes').insert({ id: 'a', data: { title: 'plaintext' } });
+			await plain.close();
+
+			let thrown: unknown;
+			try {
+				await context.adapter.open(context.configFor(scope, { encryption: encrypted }));
+			} catch (error) {
+				thrown = error;
+			}
+			expect(isCode(thrown, DiagnosticCodes.ENCRYPTION_MISMATCH)).toBe(true);
+
+			// Nothing was converted, truncated, or discarded.
+			const reopened = await context.adapter.open(context.configFor(scope));
+			expect((await reopened.collection('notes').get('a')).data.title).toBe('plaintext');
+			await reopened.close();
+		});
+
+		it('gives the key provider the scope, so an app can key per identity', async () => {
+			const seen: string[] = [];
+			const recording: KeyProvider = {
+				getKey: async resolved => {
+					seen.push(resolved.key);
+					return `key-for-${resolved.key}`;
+				},
+			};
+
+			for (const id of ['alice', 'bob']) {
+				const handle = await context.adapter.open(
+					context.configFor(
+						{ kind: 'identity', id },
+						{ encryption: { enabled: true, keyProvider: recording } },
+					),
+				);
+				await handle.close();
+			}
+
+			expect(seen).toHaveLength(2);
+			expect(new Set(seen).size).toBe(2);
+			for (const key of seen) {
+				expect(key).toMatch(/^[0-9a-f]{64}$/);
+			}
+		});
+
+		it('keeps an encrypted scope isolated from an unencrypted sibling', async () => {
+			const secure = await context.adapter.open(
+				context.configFor({ kind: 'identity', id: 'secure' }, { encryption: encrypted }),
+			);
+			await secure.collection('notes').insert({ id: 'shared', data: { title: 'secure' } });
+			await secure.close();
+
+			const open = await context.adapter.open(context.configFor({ kind: 'identity', id: 'open' }));
+			expect(await open.collection('notes').find('shared')).toBeNull();
+			await open.close();
+		});
+	});
+}