@decocms/mesh 1.0.0-alpha.1

package/dist/server/node_modules/kysely-bun-worker/README.md

@@ -0,0 +1,32 @@
+# kysely-bun-worker
+
+[kysely](https://github.com/kysely-org/kysely) dialect for `bun:sqlite`, run sql in worker
+
+## Install
+
+```shell
+bun install kysely kysely-bun-worker
+```
+
+## Config
+
+```ts
+export type BunWorkerDialectConfig = {
+  /**
+   * db file path
+   *
+   * @default ':memory:'
+   */
+  url?: string
+  onCreateConnection?: (connection: DatabaseConnection) => Promisable<void>
+  /**
+   * use bun:sqlite's built-in statment cache
+   * @see https://bun.sh/docs/api/sqlite#query
+   */
+  cacheStatment?: boolean
+  /**
+   * custom worker, default is a worker that use bun:sqlite
+   */
+  worker?: Worker
+}
+```

package/dist/server/node_modules/kysely-bun-worker/dist/index.d.mts

@@ -0,0 +1,35 @@
+import { DatabaseConnection, Dialect, Driver, QueryCompiler, DialectAdapter, Kysely, DatabaseIntrospector } from 'kysely';
+
+type Promisable<T> = T | Promise<T>;
+type BunWorkerDialectConfig = {
+    /**
+     * db file path
+     *
+     * @default ':memory:'
+     */
+    url?: string;
+    /**
+     * use `bun:sqlite` built-in statment cache
+     * @see https://bun.sh/docs/api/sqlite#query
+     */
+    cacheStatment?: boolean;
+    /**
+     * custom worker, default is a worker that use bun:sqlite
+     */
+    worker?: Worker;
+    onCreateConnection?: (connection: DatabaseConnection) => Promisable<void>;
+};
+
+declare class BunWorkerDialect implements Dialect {
+    private config?;
+    /**
+     * dialect for `bun:sqlite`, run sql in worker
+     */
+    constructor(config?: BunWorkerDialectConfig);
+    createDriver(): Driver;
+    createQueryCompiler(): QueryCompiler;
+    createAdapter(): DialectAdapter;
+    createIntrospector(db: Kysely<any>): DatabaseIntrospector;
+}
+
+export { BunWorkerDialect };

package/dist/server/node_modules/kysely-bun-worker/dist/index.d.ts

@@ -0,0 +1,35 @@
+import { DatabaseConnection, Dialect, Driver, QueryCompiler, DialectAdapter, Kysely, DatabaseIntrospector } from 'kysely';
+
+type Promisable<T> = T | Promise<T>;
+type BunWorkerDialectConfig = {
+    /**
+     * db file path
+     *
+     * @default ':memory:'
+     */
+    url?: string;
+    /**
+     * use `bun:sqlite` built-in statment cache
+     * @see https://bun.sh/docs/api/sqlite#query
+     */
+    cacheStatment?: boolean;
+    /**
+     * custom worker, default is a worker that use bun:sqlite
+     */
+    worker?: Worker;
+    onCreateConnection?: (connection: DatabaseConnection) => Promisable<void>;
+};
+
+declare class BunWorkerDialect implements Dialect {
+    private config?;
+    /**
+     * dialect for `bun:sqlite`, run sql in worker
+     */
+    constructor(config?: BunWorkerDialectConfig);
+    createDriver(): Driver;
+    createQueryCompiler(): QueryCompiler;
+    createAdapter(): DialectAdapter;
+    createIntrospector(db: Kysely<any>): DatabaseIntrospector;
+}
+
+export { BunWorkerDialect };

package/dist/server/node_modules/kysely-bun-worker/dist/index.js

@@ -0,0 +1,136 @@
+'use strict';
+
+var kysely = require('kysely');
+var events = require('events');
+
+// ../../node_modules/.pnpm/tsup@8.2.4_jiti@1.21.6_postcss@8.4.41_typescript@5.5.4_yaml@2.5.0/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+var BunWorkerDriver = class {
+  config;
+  worker;
+  connection;
+  connectionMutex = new ConnectionMutex();
+  mitt;
+  constructor(config) {
+    this.config = config;
+  }
+  async init() {
+    this.worker = this.config?.worker ?? new Worker(
+      new URL("./worker", importMetaUrl),
+      { type: "module" }
+    );
+    this.mitt = new events.EventEmitter();
+    this.worker.onmessage = ({ data: [type, data, err] }) => {
+      this.mitt?.emit(type, data, err);
+    };
+    this.worker.postMessage([
+      0,
+      // init
+      this.config?.url,
+      this.config?.cacheStatment
+    ]);
+    await new Promise((resolve, reject) => {
+      this.mitt?.once(0, (_, err) => err ? reject(err) : resolve());
+    });
+    this.connection = new BunWorkerConnection(this.worker, this.mitt);
+    await this.config?.onCreateConnection?.(this.connection);
+  }
+  async acquireConnection() {
+    await this.connectionMutex.lock();
+    return this.connection;
+  }
+  async beginTransaction(connection) {
+    await connection.executeQuery(kysely.CompiledQuery.raw("begin"));
+  }
+  async commitTransaction(connection) {
+    await connection.executeQuery(kysely.CompiledQuery.raw("commit"));
+  }
+  async rollbackTransaction(connection) {
+    await connection.executeQuery(kysely.CompiledQuery.raw("rollback"));
+  }
+  async releaseConnection() {
+    this.connectionMutex.unlock();
+  }
+  async destroy() {
+    if (!this.worker) {
+      return;
+    }
+    this.worker.postMessage([2]);
+    return new Promise((resolve, reject) => {
+      this.mitt?.once(2, (_, err) => {
+        if (err) {
+          reject(err);
+        } else {
+          this.worker?.terminate();
+          this.mitt?.removeAllListeners();
+          this.mitt = void 0;
+          resolve();
+        }
+      });
+    });
+  }
+};
+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?.();
+  }
+};
+var BunWorkerConnection = class {
+  constructor(worker, mitt) {
+    this.worker = worker;
+    this.mitt = mitt;
+  }
+  streamQuery() {
+    throw new Error("Bun:sqlite-worker driver doesn't support streaming");
+  }
+  async executeQuery(compiledQuery) {
+    const { parameters, sql, query } = compiledQuery;
+    const isSelect = kysely.SelectQueryNode.is(query);
+    this.worker.postMessage([1, isSelect, sql, parameters]);
+    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));
+    });
+  }
+};
+
+// src/index.ts
+var BunWorkerDialect = class {
+  config;
+  /**
+   * dialect for `bun:sqlite`, run sql in worker
+   */
+  constructor(config) {
+    this.config = config;
+  }
+  createDriver() {
+    return new BunWorkerDriver(this.config);
+  }
+  createQueryCompiler() {
+    return new kysely.SqliteQueryCompiler();
+  }
+  createAdapter() {
+    return new kysely.SqliteAdapter();
+  }
+  createIntrospector(db) {
+    return new kysely.SqliteIntrospector(db);
+  }
+};
+
+exports.BunWorkerDialect = BunWorkerDialect;

package/dist/server/node_modules/kysely-bun-worker/dist/index.mjs

@@ -0,0 +1,132 @@
+import { SqliteQueryCompiler, SqliteAdapter, SqliteIntrospector, CompiledQuery, SelectQueryNode } from 'kysely';
+import { EventEmitter } from 'node:events';
+
+// src/index.ts
+var BunWorkerDriver = class {
+  config;
+  worker;
+  connection;
+  connectionMutex = new ConnectionMutex();
+  mitt;
+  constructor(config) {
+    this.config = config;
+  }
+  async init() {
+    this.worker = this.config?.worker ?? new Worker(
+      new URL("./worker", import.meta.url),
+      { type: "module" }
+    );
+    this.mitt = new EventEmitter();
+    this.worker.onmessage = ({ data: [type, data, err] }) => {
+      this.mitt?.emit(type, data, err);
+    };
+    this.worker.postMessage([
+      0,
+      // init
+      this.config?.url,
+      this.config?.cacheStatment
+    ]);
+    await new Promise((resolve, reject) => {
+      this.mitt?.once(0, (_, err) => err ? reject(err) : resolve());
+    });
+    this.connection = new BunWorkerConnection(this.worker, this.mitt);
+    await this.config?.onCreateConnection?.(this.connection);
+  }
+  async acquireConnection() {
+    await this.connectionMutex.lock();
+    return this.connection;
+  }
+  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.connectionMutex.unlock();
+  }
+  async destroy() {
+    if (!this.worker) {
+      return;
+    }
+    this.worker.postMessage([2]);
+    return new Promise((resolve, reject) => {
+      this.mitt?.once(2, (_, err) => {
+        if (err) {
+          reject(err);
+        } else {
+          this.worker?.terminate();
+          this.mitt?.removeAllListeners();
+          this.mitt = void 0;
+          resolve();
+        }
+      });
+    });
+  }
+};
+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?.();
+  }
+};
+var BunWorkerConnection = class {
+  constructor(worker, mitt) {
+    this.worker = worker;
+    this.mitt = mitt;
+  }
+  streamQuery() {
+    throw new Error("Bun:sqlite-worker driver doesn't support streaming");
+  }
+  async executeQuery(compiledQuery) {
+    const { parameters, sql, query } = compiledQuery;
+    const isSelect = SelectQueryNode.is(query);
+    this.worker.postMessage([1, isSelect, sql, parameters]);
+    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));
+    });
+  }
+};
+
+// src/index.ts
+var BunWorkerDialect = class {
+  config;
+  /**
+   * dialect for `bun:sqlite`, run sql in worker
+   */
+  constructor(config) {
+    this.config = config;
+  }
+  createDriver() {
+    return new BunWorkerDriver(this.config);
+  }
+  createQueryCompiler() {
+    return new SqliteQueryCompiler();
+  }
+  createAdapter() {
+    return new SqliteAdapter();
+  }
+  createIntrospector(db) {
+    return new SqliteIntrospector(db);
+  }
+};
+
+export { BunWorkerDialect };

package/dist/server/node_modules/kysely-bun-worker/dist/worker.d.mts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/server/node_modules/kysely-bun-worker/dist/worker.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/server/node_modules/kysely-bun-worker/dist/worker.js

@@ -0,0 +1,49 @@
+'use strict';
+
+var Database = require('bun:sqlite');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Database__default = /*#__PURE__*/_interopDefault(Database);
+
+// src/worker.ts
+var db;
+var fn;
+function run(isSelect, sql, parameters) {
+  const stmt = db[fn](sql);
+  const rows = stmt.all(parameters);
+  if (isSelect || rows.length) {
+    return { rows };
+  }
+  return {
+    rows,
+    // @ts-expect-error get insert id
+    insertId: db.query("SELECT last_insert_rowid() as i").get().i,
+    // @ts-expect-error get changes
+    numAffectedRows: db.query("SELECT changes() as c").get().c
+  };
+}
+onmessage = ({ data }) => {
+  const ret = [
+    data[0],
+    null,
+    null
+  ];
+  try {
+    switch (data[0]) {
+      case 0:
+        db = new Database__default.default(data[1], { create: true });
+        fn = data[2] ? "query" : "prepare";
+        break;
+      case 1:
+        ret[1] = run(data[1], data[2], data[3] || []);
+        break;
+      case 2:
+        db.close();
+        break;
+    }
+  } catch (error) {
+    ret[2] = error;
+  }
+  postMessage(ret);
+};

package/dist/server/node_modules/kysely-bun-worker/dist/worker.mjs

@@ -0,0 +1,43 @@
+import Database from 'bun:sqlite';
+
+// src/worker.ts
+var db;
+var fn;
+function run(isSelect, sql, parameters) {
+  const stmt = db[fn](sql);
+  const rows = stmt.all(parameters);
+  if (isSelect || rows.length) {
+    return { rows };
+  }
+  return {
+    rows,
+    // @ts-expect-error get insert id
+    insertId: db.query("SELECT last_insert_rowid() as i").get().i,
+    // @ts-expect-error get changes
+    numAffectedRows: db.query("SELECT changes() as c").get().c
+  };
+}
+onmessage = ({ data }) => {
+  const ret = [
+    data[0],
+    null,
+    null
+  ];
+  try {
+    switch (data[0]) {
+      case 0:
+        db = new Database(data[1], { create: true });
+        fn = data[2] ? "query" : "prepare";
+        break;
+      case 1:
+        ret[1] = run(data[1], data[2], data[3] || []);
+        break;
+      case 2:
+        db.close();
+        break;
+    }
+  } catch (error) {
+    ret[2] = error;
+  }
+  postMessage(ret);
+};

package/dist/server/node_modules/kysely-bun-worker/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "kysely-bun-worker",
+  "version": "0.6.3",
+  "description": "kysely dialect for bun:sqlite, running in worker",
+  "author": {
+    "name": "subframe7536",
+    "email": "1667077010@qq.com"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/subframe7536/kysely-sqlite-tools/tree/master/packages/dialect-bun-worker",
+  "repository": "https://github.com/subframe7536/kysely-sqlite-tools/tree/master/packages/dialect-bun-worker",
+  "bugs": "https://github.com/subframe7536/kysely-sqlite-tools/issues",
+  "keywords": [
+    "kysely",
+    "dialect",
+    "sql",
+    "worker",
+    "sqlite3",
+    "bun"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "kysely": ">=0.26"
+  },
+  "devDependencies": {
+    "bun-types": "latest"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "test": "bun test",
+    "build": "tsup"
+  }
+}