bun-sqlite-for-rxdb 1.0.1

package/src/rxdb-helpers.ts

@@ -0,0 +1,262 @@
+import type {
+  RxStorageInstance,
+  BulkWriteRow,
+  RxDocumentData,
+  RxStorageWriteError,
+  EventBulk,
+  RxStorageChangeEvent,
+  RxStorageInstanceCreationParams,
+  RxStorageDefaultCheckpoint,
+  RxAttachmentWriteData
+} from 'rxdb';
+
+export interface AttachmentOperation {
+  documentId: string;
+  attachmentId: string;
+  attachmentData: RxAttachmentWriteData;
+  digest: string;
+}
+
+export interface AttachmentRemoveOperation {
+  documentId: string;
+  attachmentId: string;
+  digest: string;
+}
+
+function randomToken(length: number): string {
+  return Math.random().toString(36).substring(2, 2 + length);
+}
+
+function flatClone<T>(obj: T): T {
+  return Object.assign({}, obj);
+}
+
+export function getAttachmentSize(attachmentBase64String: string): number {
+  return atob(attachmentBase64String).length;
+}
+
+export function attachmentWriteDataToNormalData(writeData: RxAttachmentWriteData): any {
+  const data = writeData.data;
+  if (!data) {
+    return writeData;
+  }
+  return {
+    length: getAttachmentSize(data),
+    digest: writeData.digest,
+    type: writeData.type
+  };
+}
+
+export function stripAttachmentsDataFromDocument<T>(doc: RxDocumentData<T>): RxDocumentData<T> {
+  if (!doc._attachments || Object.keys(doc._attachments).length === 0) {
+    return doc;
+  }
+  const useDoc = flatClone(doc);
+  useDoc._attachments = {};
+  Object.entries(doc._attachments).forEach(([attachmentId, attachmentData]) => {
+    useDoc._attachments[attachmentId] = attachmentWriteDataToNormalData(attachmentData as RxAttachmentWriteData);
+  });
+  return useDoc;
+}
+
+export function stripAttachmentsDataFromRow<T>(writeRow: BulkWriteRow<T>): BulkWriteRow<T> {
+  return {
+    previous: writeRow.previous,
+    document: stripAttachmentsDataFromDocument(writeRow.document)
+  };
+}
+
+export function categorizeBulkWriteRows<RxDocType>(
+  storageInstance: RxStorageInstance<RxDocType, any, any>,
+  primaryPath: string,
+  docsInDb: Map<string, RxDocumentData<RxDocType>>,
+  bulkWriteRows: BulkWriteRow<RxDocType>[],
+  context: string
+): {
+  bulkInsertDocs: BulkWriteRow<RxDocType>[];
+  bulkUpdateDocs: BulkWriteRow<RxDocType>[];
+  errors: RxStorageWriteError<RxDocType>[];
+  eventBulk: EventBulk<RxStorageChangeEvent<RxDocumentData<RxDocType>>, RxStorageDefaultCheckpoint>;
+  newestRow?: BulkWriteRow<RxDocType>;
+  attachmentsAdd: AttachmentOperation[];
+  attachmentsRemove: AttachmentRemoveOperation[];
+  attachmentsUpdate: AttachmentOperation[];
+} {
+  const hasAttachments = !!storageInstance.schema.attachments;
+  const bulkInsertDocs: BulkWriteRow<RxDocType>[] = [];
+  const bulkUpdateDocs: BulkWriteRow<RxDocType>[] = [];
+  const errors: RxStorageWriteError<RxDocType>[] = [];
+  const events: RxStorageChangeEvent<RxDocumentData<RxDocType>>[] = [];
+  const attachmentsAdd: AttachmentOperation[] = [];
+  const attachmentsRemove: AttachmentRemoveOperation[] = [];
+  const attachmentsUpdate: AttachmentOperation[] = [];
+  let newestRow: BulkWriteRow<RxDocType> | undefined;
+
+  for (const writeRow of bulkWriteRows) {
+    const document = writeRow.document;
+    const previous = writeRow.previous;
+    const docId = document[primaryPath as keyof RxDocumentData<RxDocType>] as string;
+    const documentInDb = docsInDb.get(docId);
+    let attachmentError: RxStorageWriteError<RxDocType> | undefined;
+
+    if (!documentInDb) {
+      if (hasAttachments && document._attachments) {
+        Object.entries(document._attachments).forEach(([attachmentId, attachmentData]) => {
+          const attData = attachmentData as RxAttachmentWriteData;
+          if (!attData.data) {
+            const error: RxStorageWriteError<RxDocType> = {
+              documentId: docId,
+              isError: true,
+              status: 510,
+              writeRow,
+              attachmentId
+            } as any;
+            attachmentError = error;
+            errors.push(error);
+          } else {
+            attachmentsAdd.push({
+              documentId: docId,
+              attachmentId,
+              attachmentData: attData,
+              digest: attData.digest
+            });
+          }
+        });
+      }
+
+      if (!attachmentError) {
+        if (hasAttachments) {
+          bulkInsertDocs.push(stripAttachmentsDataFromRow(writeRow));
+        } else {
+          bulkInsertDocs.push(writeRow);
+        }
+        newestRow = writeRow;
+      }
+
+      if (!document._deleted) {
+        events.push({
+          documentId: docId,
+          operation: 'INSERT',
+          documentData: hasAttachments ? stripAttachmentsDataFromDocument(document) : document,
+          previousDocumentData: hasAttachments && previous ? stripAttachmentsDataFromDocument(previous) : previous
+        });
+      }
+    } else {
+      if (!previous || documentInDb._rev !== previous._rev) {
+        errors.push({
+          isError: true,
+          status: 409,
+          documentId: docId,
+          writeRow,
+          documentInDb
+        });
+        continue;
+      }
+
+      const updatedRow = hasAttachments ? stripAttachmentsDataFromRow(writeRow) : writeRow;
+
+      if (hasAttachments) {
+        if (document._deleted) {
+          if (previous && previous._attachments) {
+            Object.keys(previous._attachments).forEach(attachmentId => {
+              attachmentsRemove.push({
+                documentId: docId,
+                attachmentId,
+                digest: previous._attachments[attachmentId].digest
+              });
+            });
+          }
+        } else if (document._attachments) {
+          Object.entries(document._attachments).forEach(([attachmentId, attachmentData]) => {
+            const attData = attachmentData as RxAttachmentWriteData;
+            const previousAttachmentData = previous && previous._attachments ? previous._attachments[attachmentId] : undefined;
+            
+            if (!previousAttachmentData) {
+              if (!attData.data) {
+                const error: RxStorageWriteError<RxDocType> = {
+                  documentId: docId,
+                  documentInDb,
+                  isError: true,
+                  status: 510,
+                  writeRow,
+                  attachmentId
+                } as any;
+                attachmentError = error;
+              } else {
+                attachmentsAdd.push({
+                  documentId: docId,
+                  attachmentId,
+                  attachmentData: attData,
+                  digest: attData.digest
+                });
+              }
+            } else {
+              const newDigest = updatedRow.document._attachments[attachmentId].digest;
+              if (attData.data && previousAttachmentData.digest !== newDigest) {
+                attachmentsUpdate.push({
+                  documentId: docId,
+                  attachmentId,
+                  attachmentData: attData,
+                  digest: attData.digest
+                });
+              }
+            }
+          });
+        }
+      }
+
+      if (attachmentError) {
+        errors.push(attachmentError);
+      } else {
+        bulkUpdateDocs.push(updatedRow);
+        newestRow = updatedRow;
+      }
+
+      const previousDeleted = previous && previous._deleted;
+      const documentDeleted = document._deleted;
+      let operation: 'INSERT' | 'UPDATE' | 'DELETE';
+      
+      if (previousDeleted && !documentDeleted) {
+        operation = 'INSERT';
+      } else if (!documentDeleted) {
+        operation = 'UPDATE';
+      } else {
+        operation = 'DELETE';
+      }
+
+      events.push({
+        documentId: docId,
+        documentData: hasAttachments ? stripAttachmentsDataFromDocument(document) : document,
+        previousDocumentData: previous,
+        operation
+      });
+    }
+  }
+
+  return {
+    bulkInsertDocs,
+    bulkUpdateDocs,
+    errors,
+    newestRow,
+    eventBulk: {
+      checkpoint: { id: '', lwt: 0 },
+      context,
+      events,
+      id: randomToken(10)
+    },
+    attachmentsAdd,
+    attachmentsRemove,
+    attachmentsUpdate
+  };
+}
+
+export function ensureRxStorageInstanceParamsAreCorrect(
+  params: RxStorageInstanceCreationParams<any, any>
+): void {
+  if (params.schema.keyCompression) {
+    throw new Error('UT5: RX_SCHEMA_KEY_COMPRESSION_USED');
+  }
+  if (params.schema.encrypted && params.schema.encrypted.length > 0 && !params.password) {
+    throw new Error('UT6: RX_SCHEMA_ENCRYPTED_FIELDS_MISSING_PASSWORD');
+  }
+}

package/src/schema-version-isolation.test.ts

@@ -0,0 +1,126 @@
+import { describe, test, expect, afterEach } from 'bun:test';
+import { BunSQLiteStorageInstance } from './instance';
+import type { RxStorageInstanceCreationParams } from 'rxdb';
+
+describe('Schema Version Isolation', () => {
+	const instances: BunSQLiteStorageInstance<any>[] = [];
+
+	afterEach(async () => {
+		for (const instance of instances) {
+			await instance.close();
+		}
+		instances.length = 0;
+	});
+
+	test('different schema versions should use different tables', async () => {
+		const baseParams = {
+			databaseName: 'testdb',
+			collectionName: 'users',
+			databaseInstanceToken: 'test',
+			options: {},
+			devMode: false,
+			multiInstance: false
+		};
+
+		const instanceV0 = new BunSQLiteStorageInstance({
+			...baseParams,
+			schema: {
+				version: 0,
+				primaryKey: 'id',
+				type: 'object',
+				properties: { id: { type: 'string' } }
+			},
+			internals: {}
+		} as RxStorageInstanceCreationParams<any, any>);
+		instances.push(instanceV0);
+
+		const instanceV1 = new BunSQLiteStorageInstance({
+			...baseParams,
+			schema: {
+				version: 1,
+				primaryKey: 'id',
+				type: 'object',
+				properties: { id: { type: 'string' } }
+			},
+			internals: {}
+		} as RxStorageInstanceCreationParams<any, any>);
+		instances.push(instanceV1);
+
+		const docV0 = {
+			id: 'doc1',
+			_deleted: false,
+			_attachments: {},
+			_meta: { lwt: Date.now() },
+			_rev: '1-abc'
+		};
+
+		const docV1 = {
+			id: 'doc2',
+			_deleted: false,
+			_attachments: {},
+			_meta: { lwt: Date.now() },
+			_rev: '1-def'
+		};
+
+		await instanceV0.bulkWrite([{ document: docV0 }], 'test');
+		await instanceV1.bulkWrite([{ document: docV1 }], 'test');
+
+		const docsV0 = await instanceV0.findDocumentsById(['doc1', 'doc2'], false);
+		const docsV1 = await instanceV1.findDocumentsById(['doc1', 'doc2'], false);
+
+		expect(docsV0.length).toBe(1);
+		expect(docsV0[0].id).toBe('doc1');
+
+		expect(docsV1.length).toBe(1);
+		expect(docsV1[0].id).toBe('doc2');
+	});
+
+	test('same schema version should share table', async () => {
+		const baseParams = {
+			databaseName: 'testdb',
+			collectionName: 'users',
+			databaseInstanceToken: 'test',
+			options: {},
+			devMode: false,
+			multiInstance: false
+		};
+
+		const instance1 = new BunSQLiteStorageInstance({
+			...baseParams,
+			schema: {
+				version: 0,
+				primaryKey: 'id',
+				type: 'object',
+				properties: { id: { type: 'string' } }
+			},
+			internals: {}
+		} as RxStorageInstanceCreationParams<any, any>);
+		instances.push(instance1);
+
+		const instance2 = new BunSQLiteStorageInstance({
+			...baseParams,
+			schema: {
+				version: 0,
+				primaryKey: 'id',
+				type: 'object',
+				properties: { id: { type: 'string' } }
+			},
+			internals: {}
+		} as RxStorageInstanceCreationParams<any, any>);
+		instances.push(instance2);
+
+		const doc = {
+			id: 'doc1',
+			_deleted: false,
+			_attachments: {},
+			_meta: { lwt: Date.now() },
+			_rev: '1-abc'
+		};
+
+		await instance1.bulkWrite([{ document: doc }], 'test');
+
+		const docs = await instance2.findDocumentsById(['doc1'], false);
+		expect(docs.length).toBe(1);
+		expect(docs[0].id).toBe('doc1');
+	});
+});

package/src/statement-manager.ts

@@ -0,0 +1,69 @@
+import type { Database, Statement, Changes } from 'bun:sqlite';
+
+export type QueryWithParams = {
+	query: string;
+	params: any[];
+};
+
+export class StatementManager {
+	private db: Database;
+	private staticStatements = new Map<string, Statement>();
+
+	constructor(db: Database) {
+		this.db = db;
+	}
+
+	all(queryWithParams: QueryWithParams): any[] {
+		const { query, params } = queryWithParams;
+
+		if (this.isStaticSQL(query)) {
+			let stmt = this.staticStatements.get(query);
+			if (!stmt) {
+				stmt = this.db.query(query);
+				this.staticStatements.set(query, stmt);
+			}
+			return stmt.all(...params);
+		} else {
+			const stmt = this.db.prepare(query);
+			try {
+				return stmt.all(...params);
+			} finally {
+				stmt.finalize();
+			}
+		}
+	}
+
+	run(queryWithParams: QueryWithParams): Changes {
+		const { query, params } = queryWithParams;
+
+		if (this.isStaticSQL(query)) {
+			let stmt = this.staticStatements.get(query);
+			if (!stmt) {
+				stmt = this.db.query(query);
+				this.staticStatements.set(query, stmt);
+			}
+			return stmt.run(...params);
+		} else {
+			const stmt = this.db.prepare(query);
+			try {
+				return stmt.run(...params);
+			} finally {
+				stmt.finalize();
+			}
+		}
+	}
+
+	close(): void {
+		for (const stmt of this.staticStatements.values()) {
+			stmt.finalize();
+		}
+		this.staticStatements.clear();
+	}
+
+	private isStaticSQL(query: string): boolean {
+		if (query.includes('WHERE (')) {
+			return false;
+		}
+		return true;
+	}
+}