kysely-generic-sqlite/dist/worker.js

Generic kysely dialect for SQLite, support run in main thread or worker

import { BaseSqliteDriver, BaseSqliteDialect } from './chunk-YWE62C55.js';
import { initEvent, closeEvent, dataEvent, endEvent, runEvent } from './chunk-DJ5QD4ZI.js';
export { access, createGenericOnMessageCallback } from './chunk-DJ5QD4ZI.js';
import { SelectQueryNode } from 'kysely';

var GenericSqliteWorkerDriver = class extends BaseSqliteDriver {
  worker;
  mitt;
  constructor(executor, onCreateConnection) {
    super(async () => {
      const exec = await executor();
      this.mitt = exec.mitt;
      this.worker = exec.worker;
      exec.handle(
        this.worker,
        ([type, ...msg]) => this.mitt.emit(type, ...msg)
      );
      this.worker.postMessage([
        initEvent,
        exec.data || {}
      ]);
      await new Promise((resolve, reject) => {
        this.mitt.once(initEvent, (_, err) => err ? reject(err) : resolve());
      });
      this.conn = new GenericSqliteWorkerConnection(this.worker, this.mitt);
      await onCreateConnection?.(this.conn);
    });
  }
  async destroy() {
    if (!this.worker) {
      return;
    }
    this.worker.postMessage([closeEvent]);
    return new Promise(
      (resolve, reject) => this.mitt?.once(
        closeEvent,
        (_, err) => err ? reject(err) : resolve()
      )
    ).finally(() => {
      this.worker?.terminate();
      this.mitt?.off();
      this.mitt = this.worker = void 0;
    });
  }
};
var GenericSqliteWorkerConnection = class {
  constructor(worker, mitt) {
    this.worker = worker;
    this.mitt = mitt;
  }
  async *streamQuery({ parameters, sql, query }) {
    this.worker.postMessage([
      dataEvent,
      SelectQueryNode.is(query),
      sql,
      parameters
    ]);
    let done = false;
    let resolveFn;
    let rejectFn;
    this.mitt.on(dataEvent, (data, err) => {
      if (err) {
        rejectFn(err);
      } else {
        resolveFn([{ rows: [data] }, false]);
      }
    });
    this.mitt.on(endEvent, (_, err) => {
      if (err) {
        rejectFn(err);
      } else {
        resolveFn([void 0, true]);
      }
    });
    while (!done) {
      const [data, isDone] = await new Promise((res, rej) => {
        resolveFn = res;
        rejectFn = rej;
      });
      if (isDone) {
        done = true;
        this.mitt?.off(dataEvent);
        this.mitt?.off(endEvent);
      } else {
        yield data;
      }
    }
  }
  async executeQuery(compiledQuery) {
    const { parameters, sql, query } = compiledQuery;
    this.worker.postMessage([
      runEvent,
      SelectQueryNode.is(query),
      sql,
      parameters
    ]);
    return await new Promise((resolve, reject) => {
      if (!this.mitt) {
        reject(new Error("kysely instance has been destroyed"));
      }
      this.mitt.once(runEvent, (data, err) => !err && data ? resolve(data) : reject(err));
    });
  }
};

// src/worker/dialect.ts
var GenericSqliteWorkerDialect = class extends BaseSqliteDialect {
  /**
   * Dialect for generic SQLite that run SQLs in worker thread
   *
   * @param executor function to create {@link IGenericSqliteWorkerExecutor}
   * @param onCreateConnection optional callback after connection created
   */
  constructor(executor, onCreateConnection) {
    super(() => new GenericSqliteWorkerDriver(executor, onCreateConnection));
  }
};

export { GenericSqliteWorkerDialect, GenericSqliteWorkerDriver };