kysely-generic-sqlite/dist/chunk-YWE62C55.js

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

import { SqliteQueryCompiler, SqliteAdapter, SqliteIntrospector, CompiledQuery, RawNode, IdentifierNode } from 'kysely';

// src/base.ts
var BaseSqliteDialect = class {
  /**
   * Base class that implements {@link Dialect}
   * @param create function that create {@link Driver}
   */
  constructor(create) {
    this.createDriver = create;
  }
  createDriver;
  createQueryCompiler() {
    return new SqliteQueryCompiler();
  }
  createAdapter() {
    return new SqliteAdapter();
  }
  createIntrospector(db) {
    return new SqliteIntrospector(db);
  }
};
var ConnectionMutex = class {
  promise;
  resolve;
  async lock() {
    while (this.promise) {
      await this.promise;
    }
    this.promise = new Promise((resolve) => {
      this.resolve = resolve;
    });
  }
  unlock() {
    const resolve = this.resolve;
    this.promise = void 0;
    this.resolve = void 0;
    resolve?.();
  }
};
async function runSavepoint(command, createQueryId, connection, savepointName, compileQuery) {
  await connection.executeQuery(
    compileQuery(
      RawNode.createWithChildren([
        RawNode.createWithSql(`${command} `),
        IdentifierNode.create(savepointName)
        // ensures savepointName gets sanitized
      ]),
      createQueryId()
    )
  );
}
var BaseSqliteDriver = class {
  mutex = new ConnectionMutex();
  conn;
  savepoint;
  releaseSavepoint;
  rollbackToSavepoint;
  init;
  /**
   * Base abstract class that implements {@link Driver}
   *
   * You **MUST** assign `this.conn` in `init` and implement `destroy` method
   */
  constructor(init) {
    this.init = () => import('kysely').then(({ createQueryId }) => {
      if (createQueryId) {
        this.savepoint = runSavepoint.bind(null, "savepoint", createQueryId);
        this.releaseSavepoint = runSavepoint.bind(null, "release", createQueryId);
        this.rollbackToSavepoint = runSavepoint.bind(null, "rollback to", createQueryId);
      }
    }).then(init);
  }
  async acquireConnection() {
    await this.mutex.lock();
    return this.conn;
  }
  async beginTransaction(connection) {
    await connection.executeQuery(CompiledQuery.raw("begin"));
  }
  async commitTransaction(connection) {
    await connection.executeQuery(CompiledQuery.raw("commit"));
  }
  async rollbackTransaction(connection) {
    await connection.executeQuery(CompiledQuery.raw("rollback"));
  }
  async releaseConnection() {
    this.mutex.unlock();
  }
};
function buildQueryFnAlt(exec) {
  return async (isSelect, sql, parameters) => isSelect ? { rows: await exec.all(sql, parameters) } : { rows: [], ...await exec.run(sql, parameters) };
}
function buildQueryFn(exec) {
  return async (isSelect, sql, parameters) => {
    const rows = await exec.all(sql, parameters);
    return isSelect || rows.length ? { rows } : { rows: [], ...await exec.run("select 1") };
  };
}
function parseBigInt(num) {
  return num === void 0 || num === null ? void 0 : BigInt(num);
}

export { BaseSqliteDialect, BaseSqliteDriver, buildQueryFn, buildQueryFnAlt, parseBigInt };