feat(db): sqlite in worker (not working right now)

src/lib/kysely-official-wasm-worker/driver.ts

@@ -0,0 +1,183 @@
+import type { DatabaseConnection, Driver, QueryResult } from "kysely";
+import { CompiledQuery, SelectQueryNode } from "kysely";
+import type { Emitter } from "zen-mitt";
+import { mitt } from "zen-mitt";
+import type { EventWithError, MainToWorkerMsg, OfficialWasmWorkerDialectConfig, WorkerToMainMsg } from "./type";
+import workerUrl from "./worker?url";
+
+export class OfficialWasmWorkerDriver implements Driver {
+  private worker?: Worker;
+  private connection?: DatabaseConnection;
+  private connectionMutex = new ConnectionMutex();
+  private mitt?: Emitter<EventWithError>;
+  constructor(private config: OfficialWasmWorkerDialectConfig) {}
+
+  async init(): Promise<void> {
+    // try to persist storage, https://web.dev/articles/persistent-storage#request_persistent_storage
+    try {
+      if (navigator.storage?.persist && !(await navigator.storage.persisted())) {
+        await navigator.storage.persist();
+      }
+      // biome-ignore lint/suspicious/noEmptyBlockStatements: <explanation>
+    } catch {}
+
+    this.mitt = mitt<EventWithError>();
+
+    this.worker =
+      this.config.worker ??
+      new Worker(workerUrl, {
+        type: "module",
+      });
+
+    this.worker.onmessage = ({ data: [type, ...msg] }: MessageEvent<WorkerToMainMsg>) => {
+      this.mitt?.emit(type, ...msg);
+    };
+
+    this.worker.postMessage([0, this.config.fileName, this.config.preferOPFS ?? false] satisfies MainToWorkerMsg);
+
+    await new Promise<void>((resolve, reject) => {
+      this.mitt?.once(0, (_, err) => (err ? reject(err) : resolve()));
+    });
+
+    this.connection = new OfficialWasmWorkerConnection(this.worker, this.mitt);
+    await this.config.onCreateConnection?.(this.connection);
+  }
+
+  async acquireConnection(): Promise<DatabaseConnection> {
+    // SQLite only has one single connection. We use a mutex here to wait
+    // until the single connection has been released.
+    await this.connectionMutex.lock();
+
+    // biome-ignore lint/style/noNonNullAssertion: <explanation>
+    return this.connection!;
+  }
+
+  async beginTransaction(connection: DatabaseConnection): Promise<void> {
+    await connection.executeQuery(CompiledQuery.raw("begin"));
+  }
+
+  async commitTransaction(connection: DatabaseConnection): Promise<void> {
+    await connection.executeQuery(CompiledQuery.raw("commit"));
+  }
+
+  async rollbackTransaction(connection: DatabaseConnection): Promise<void> {
+    await connection.executeQuery(CompiledQuery.raw("rollback"));
+  }
+
+  releaseConnection(): Promise<void> {
+    return new Promise((resolve) => {
+      this.connectionMutex.unlock();
+
+      resolve();
+    });
+  }
+
+  async destroy(): Promise<void> {
+    if (!this.worker) {
+      return;
+    }
+    this.worker.postMessage([2] satisfies MainToWorkerMsg);
+    return new Promise<void>((resolve, reject) => {
+      this.mitt?.once(2, (_, err) => {
+        if (err) {
+          reject(err);
+        } else {
+          this.worker?.terminate();
+          this.mitt?.off();
+          this.mitt = undefined;
+          resolve();
+        }
+      });
+    });
+  }
+}
+
+class ConnectionMutex {
+  private promise?: Promise<void>;
+  private resolve?: () => void;
+
+  async lock(): Promise<void> {
+    while (this.promise) {
+      await this.promise;
+    }
+
+    this.promise = new Promise((resolve) => {
+      this.resolve = resolve;
+    });
+  }
+
+  unlock(): void {
+    const resolve = this.resolve;
+
+    this.promise = undefined;
+    this.resolve = undefined;
+
+    resolve?.();
+  }
+}
+
+class OfficialWasmWorkerConnection implements DatabaseConnection {
+  readonly worker: Worker;
+  readonly mitt?: Emitter<EventWithError>;
+  constructor(worker: Worker, mitt?: Emitter<EventWithError>) {
+    this.worker = worker;
+    this.mitt = mitt;
+  }
+
+  async *streamQuery<R>(compiledQuery: CompiledQuery): AsyncIterableIterator<QueryResult<R>> {
+    const { parameters, sql, query } = compiledQuery;
+    if (!SelectQueryNode.is(query)) {
+      throw new Error("official wasm worker dialect only supports SELECT queries for streaming");
+    }
+    this.worker.postMessage([3, sql, parameters] satisfies MainToWorkerMsg);
+    let done = false;
+    let resolveFn: (value: IteratorResult<QueryResult<R>>) => void;
+    let rejectFn: (reason?: unknown) => void;
+
+    this.mitt?.on(3 /* data */, (data, err): void => {
+      if (err) {
+        rejectFn(err);
+      } else {
+        resolveFn({ value: { rows: data as R[] }, done: false });
+      }
+    });
+
+    this.mitt?.on(4 /* end */, (_, err): void => {
+      if (err) {
+        rejectFn(err);
+      } else {
+        resolveFn({ value: undefined, done: true });
+      }
+    });
+
+    while (!done) {
+      const result = await new Promise<IteratorResult<QueryResult<R>>>((res, rej) => {
+        resolveFn = res;
+        rejectFn = rej;
+      });
+
+      if (result.done) {
+        done = true;
+        this.mitt?.off(3 /* data */);
+        this.mitt?.off(4 /* end */);
+      } else {
+        yield result.value;
+      }
+    }
+  }
+
+  async executeQuery<R>(compiledQuery: CompiledQuery<unknown>): Promise<QueryResult<R>> {
+    const { sql, parameters, query } = compiledQuery;
+
+    const isSelect = SelectQueryNode.is(query);
+
+    this.worker.postMessage([1, isSelect, sql, parameters] satisfies MainToWorkerMsg);
+    return new Promise((resolve, reject) => {
+      if (!this.mitt) {
+        reject(new Error("kysely instance has been destroyed"));
+      }
+
+      this.mitt?.once(1, (data, err) => (!err && data ? resolve(data) : reject(err)));
+    });
+  }
+}