kysely-generic-sqlite/dist/worker-helper-node.cjs

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

'use strict';

var events = require('events');
var worker_threads = require('worker_threads');

// src/worker/node-helper.ts

// src/worker/types.ts
var initEvent = "0";
var runEvent = "1";
var closeEvent = "2";
var dataEvent = "3";
var endEvent = "4";

// src/worker/utils.ts
function createGenericOnMessageCallback(init, post, message) {
  let db;
  return async ([type, data1, data2, data3]) => {
    const ret = [type, null, null];
    try {
      switch (type) {
        case initEvent: {
          db = await init(data1);
          break;
        }
        case runEvent: {
          ret[1] = await db.query(data1, data2, data3);
          break;
        }
        case closeEvent: {
          await db.close();
          break;
        }
        case dataEvent: {
          if (!db.iterator) {
            throw new Error("streamQuery() is not supported.");
          }
          const it = db.iterator(data1, data2, data3);
          for await (const row of it) {
            post([type, row, null]);
          }
          ret[0] = endEvent;
          break;
        }
        default: {
          if (message) {
            const data = await message(db, type, data1, data2, data3);
            if (data !== void 0 && data !== null) {
              ret[1] = data;
            }
          }
        }
      }
    } catch (error) {
      ret[2] = error;
    }
    post(ret);
  };
}
async function access(data) {
  return typeof data === "function" ? await data() : data;
}

// src/worker/node-helper.ts
var NodeEventEmitterWrapper = class extends events.EventEmitter {
  off(eventName) {
    return this.removeAllListeners(eventName);
  }
};
function createNodeOnMessageCallback(init, rest) {
  if (!worker_threads.parentPort) {
    throw new Error("Must run in a worker thread");
  }
  worker_threads.parentPort.on(
    "message",
    createGenericOnMessageCallback(
      init,
      (value) => worker_threads.parentPort.postMessage(value),
      rest
    )
  );
}
var handleNodeWorker = (worker, cb) => worker.on("message", cb);
function createNodeMitt() {
  return new NodeEventEmitterWrapper();
}
function createNodeWorkerExecutor(config) {
  const { worker, data } = config;
  return async () => ({
    data,
    worker: await access(worker),
    handle: handleNodeWorker,
    mitt: createNodeMitt()
  });
}

exports.createNodeMitt = createNodeMitt;
exports.createNodeOnMessageCallback = createNodeOnMessageCallback;
exports.createNodeWorkerExecutor = createNodeWorkerExecutor;
exports.handleNodeWorker = handleNodeWorker;