@buenojs/bueno 0.8.4 → 0.8.6

package/dist/database/index.js

@@ -0,0 +1,493 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/database/index.ts
+function detectDriver(url) {
+  if (url.startsWith("mysql://") || url.startsWith("mysql2://")) {
+    return "mysql";
+  }
+  if (url.startsWith("sqlite://") || url.startsWith("file://") || url.startsWith("file:") || url === ":memory:" || url.endsWith(".db") || url.endsWith(".sqlite") || url.endsWith(".sqlite3")) {
+    return "sqlite";
+  }
+  return "postgresql";
+}
+function detectOperationType(sql) {
+  const normalizedSql = sql.trim().toUpperCase();
+  if (normalizedSql.startsWith("SELECT"))
+    return "query";
+  if (normalizedSql.startsWith("INSERT"))
+    return "insert";
+  if (normalizedSql.startsWith("UPDATE"))
+    return "update";
+  if (normalizedSql.startsWith("DELETE"))
+    return "delete";
+  return "other";
+}
+
+class Database {
+  config;
+  driver;
+  sql = null;
+  _isConnected = false;
+  enableMetrics;
+  slowQueryThreshold;
+  metrics = {
+    queries: 0,
+    inserts: 0,
+    updates: 0,
+    deletes: 0,
+    errors: 0,
+    avgLatency: 0,
+    totalLatency: 0,
+    slowQueries: 0,
+    totalOperations: 0
+  };
+  eventListeners = new Map;
+  constructor(config) {
+    this.config = typeof config === "string" ? { url: config } : config;
+    this.driver = this.config.driver ?? detectDriver(this.config.url);
+    this.enableMetrics = this.config.enableMetrics ?? true;
+    this.slowQueryThreshold = this.config.slowQueryThreshold ?? 100;
+  }
+  getTimestamp() {
+    try {
+      return Bun.nanoseconds() / 1e6;
+    } catch {
+      return performance.now();
+    }
+  }
+  getMetrics() {
+    return { ...this.metrics };
+  }
+  resetMetrics() {
+    this.metrics = {
+      queries: 0,
+      inserts: 0,
+      updates: 0,
+      deletes: 0,
+      errors: 0,
+      avgLatency: 0,
+      totalLatency: 0,
+      slowQueries: 0,
+      totalOperations: 0
+    };
+  }
+  updateMetrics(operationType, latency, error) {
+    if (!this.enableMetrics)
+      return;
+    this.metrics.totalOperations++;
+    this.metrics.totalLatency += latency;
+    this.metrics.avgLatency = this.metrics.totalLatency / this.metrics.totalOperations;
+    if (latency > this.slowQueryThreshold) {
+      this.metrics.slowQueries++;
+    }
+    if (error) {
+      this.metrics.errors++;
+    }
+    switch (operationType) {
+      case "query":
+        this.metrics.queries++;
+        break;
+      case "insert":
+        this.metrics.inserts++;
+        break;
+      case "update":
+        this.metrics.updates++;
+        break;
+      case "delete":
+        this.metrics.deletes++;
+        break;
+    }
+  }
+  emitEvent(event) {
+    const listeners = this.eventListeners.get(event.type);
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          listener(event);
+        } catch (e) {
+          console.error("Database event listener error:", e);
+        }
+      }
+    }
+  }
+  on(eventType, listener) {
+    if (!this.eventListeners.has(eventType)) {
+      this.eventListeners.set(eventType, new Set);
+    }
+    this.eventListeners.get(eventType)?.add(listener);
+  }
+  off(eventType, listener) {
+    this.eventListeners.get(eventType)?.delete(listener);
+  }
+  removeAllListeners(eventType) {
+    if (eventType) {
+      this.eventListeners.delete(eventType);
+    } else {
+      this.eventListeners.clear();
+    }
+  }
+  getDriver() {
+    return this.driver;
+  }
+  async connect() {
+    if (this._isConnected)
+      return;
+    try {
+      const { SQL } = await Promise.resolve(globalThis.Bun);
+      const options = {};
+      if (this.driver === "sqlite") {
+        options.adapter = "sqlite";
+        if (!this.config.url.startsWith("sqlite://") && !this.config.url.startsWith("file:") && this.config.url !== ":memory:") {
+          options.filename = this.config.url;
+        }
+      }
+      if (this.config.pool) {
+        if (this.config.pool.max)
+          options.max = this.config.pool.max;
+        if (this.config.pool.idleTimeout)
+          options.idleTimeout = this.config.pool.idleTimeout;
+        if (this.config.pool.maxLifetime)
+          options.maxLifetime = this.config.pool.maxLifetime;
+        if (this.config.pool.connectionTimeout)
+          options.connectionTimeout = this.config.pool.connectionTimeout;
+      }
+      if (this.config.tls !== undefined) {
+        options.tls = this.config.tls;
+      }
+      if (this.config.bigint !== undefined) {
+        options.bigint = this.config.bigint;
+      }
+      if (this.config.prepare !== undefined) {
+        options.prepare = this.config.prepare;
+      }
+      if (Object.keys(options).length > 0 && !this.config.url.startsWith("sqlite://")) {
+        this.sql = new SQL(this.config.url, options);
+      } else {
+        this.sql = new SQL(this.config.url);
+      }
+      this._isConnected = true;
+    } catch (error) {
+      throw new Error(`Failed to connect to database: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  get isConnected() {
+    return this._isConnected;
+  }
+  getSql() {
+    return this.sql;
+  }
+  async query(strings, ...values) {
+    this.ensureConnection();
+    const sql = strings.join("?");
+    const operationType = detectOperationType(sql);
+    const startTime = this.getTimestamp();
+    this.emitEvent({
+      type: "query:start",
+      sql,
+      params: values,
+      operationType
+    });
+    try {
+      const sqlFn = this.sql;
+      const results = await sqlFn(strings, ...values);
+      const latency = this.getTimestamp() - startTime;
+      this.updateMetrics(operationType, latency, false);
+      this.emitEvent({
+        type: "query:end",
+        sql,
+        params: values,
+        latency,
+        operationType
+      });
+      return results;
+    } catch (error) {
+      const latency = this.getTimestamp() - startTime;
+      this.updateMetrics(operationType, latency, true);
+      this.emitEvent({
+        type: "query:error",
+        sql,
+        params: values,
+        latency,
+        error: error instanceof Error ? error : new Error(String(error)),
+        operationType
+      });
+      throw error;
+    }
+  }
+  async queryOne(strings, ...values) {
+    const results = await this.query(strings, ...values);
+    return results.length > 0 ? results[0] : null;
+  }
+  async execute(strings, ...values) {
+    this.ensureConnection();
+    const sql = strings.join("?");
+    const operationType = detectOperationType(sql);
+    const startTime = this.getTimestamp();
+    this.emitEvent({
+      type: "query:start",
+      sql,
+      params: values,
+      operationType
+    });
+    try {
+      const sqlFn = this.sql;
+      const results = await sqlFn(strings, ...values);
+      const latency = this.getTimestamp() - startTime;
+      this.updateMetrics(operationType, latency, false);
+      this.emitEvent({
+        type: "query:end",
+        sql,
+        params: values,
+        latency,
+        operationType
+      });
+      return {
+        rows: results,
+        rowCount: results.length
+      };
+    } catch (error) {
+      const latency = this.getTimestamp() - startTime;
+      this.updateMetrics(operationType, latency, true);
+      this.emitEvent({
+        type: "query:error",
+        sql,
+        params: values,
+        latency,
+        error: error instanceof Error ? error : new Error(String(error)),
+        operationType
+      });
+      throw error;
+    }
+  }
+  async raw(sqlString, params = []) {
+    this.ensureConnection();
+    const operationType = detectOperationType(sqlString);
+    const startTime = this.getTimestamp();
+    this.emitEvent({
+      type: "query:start",
+      sql: sqlString,
+      params,
+      operationType
+    });
+    try {
+      const sql = this.sql;
+      let results;
+      if (sql.unsafe) {
+        if (this.driver === "sqlite") {
+          let query = sqlString;
+          let i = 1;
+          while (query.includes(`$${i}`)) {
+            query = query.replace(`$${i}`, "?");
+            i++;
+          }
+          results = await sql.unsafe(query, params);
+        } else {
+          results = await sql.unsafe(sqlString, params);
+        }
+      } else {
+        throw new Error("Raw SQL not supported");
+      }
+      const latency = this.getTimestamp() - startTime;
+      this.updateMetrics(operationType, latency, false);
+      this.emitEvent({
+        type: "query:end",
+        sql: sqlString,
+        params,
+        latency,
+        operationType
+      });
+      return results;
+    } catch (error) {
+      const latency = this.getTimestamp() - startTime;
+      this.updateMetrics(operationType, latency, true);
+      this.emitEvent({
+        type: "query:error",
+        sql: sqlString,
+        params,
+        latency,
+        error: error instanceof Error ? error : new Error(String(error)),
+        operationType
+      });
+      throw error;
+    }
+  }
+  async transaction(callback) {
+    this.ensureConnection();
+    const sql = this.sql;
+    return sql.begin(async (tx) => {
+      const txWrapper = {
+        query: async (strings, ...values) => {
+          const t = tx;
+          return t(strings, ...values);
+        },
+        queryOne: async (strings, ...values) => {
+          const results = await txWrapper.query(strings, ...values);
+          return results.length > 0 ? results[0] : null;
+        },
+        execute: async (strings, ...values) => {
+          const t = tx;
+          const results = await t(strings, ...values);
+          return { rows: results, rowCount: results.length };
+        }
+      };
+      return callback(txWrapper);
+    });
+  }
+  async beginDistributed(name, callback) {
+    this.ensureConnection();
+    const sql = this.sql;
+    if (!sql.beginDistributed) {
+      throw new Error("Distributed transactions not supported for this database");
+    }
+    return sql.beginDistributed(name, async (tx) => {
+      const txWrapper = {
+        query: async (strings, ...values) => {
+          const t = tx;
+          return t(strings, ...values);
+        },
+        queryOne: async (strings, ...values) => {
+          const results = await txWrapper.query(strings, ...values);
+          return results.length > 0 ? results[0] : null;
+        },
+        execute: async (strings, ...values) => {
+          const t = tx;
+          const results = await t(strings, ...values);
+          return { rows: results, rowCount: results.length };
+        }
+      };
+      return callback(txWrapper);
+    });
+  }
+  async commitDistributed(name) {
+    const sql = this.sql;
+    if (sql.commitDistributed) {
+      await sql.commitDistributed(name);
+    }
+  }
+  async rollbackDistributed(name) {
+    const sql = this.sql;
+    if (sql.rollbackDistributed) {
+      await sql.rollbackDistributed(name);
+    }
+  }
+  async reserve() {
+    this.ensureConnection();
+    const sql = this.sql;
+    if (!sql.reserve) {
+      throw new Error("Connection reservation not supported");
+    }
+    const reserved = await sql.reserve();
+    return new ReservedConnection(reserved);
+  }
+  async close(options) {
+    if (!this._isConnected)
+      return;
+    const sql = this.sql;
+    if (sql.close) {
+      await sql.close(options);
+    }
+    this.sql = null;
+    this._isConnected = false;
+  }
+  async values(strings, ...values) {
+    this.ensureConnection();
+    const sql = this.sql;
+    return sql(strings, ...values).values();
+  }
+  async rawFormat(strings, ...values) {
+    this.ensureConnection();
+    const sql = this.sql;
+    return sql(strings, ...values).raw();
+  }
+  async simple(strings, ...values) {
+    this.ensureConnection();
+    const sql = this.sql;
+    return sql(strings, ...values).simple();
+  }
+  async file(path, params = []) {
+    this.ensureConnection();
+    const sql = this.sql;
+    if (sql.file) {
+      return sql.file(path, params);
+    }
+    throw new Error("File execution not supported");
+  }
+  ensureConnection() {
+    if (!this._isConnected || !this.sql) {
+      throw new Error("Database not connected. Call connect() first.");
+    }
+  }
+}
+
+class ReservedConnection {
+  connection;
+  constructor(connection) {
+    this.connection = connection;
+  }
+  async query(strings, ...values) {
+    const conn = this.connection;
+    return conn(strings, ...values);
+  }
+  async queryOne(strings, ...values) {
+    const results = await this.query(strings, ...values);
+    return results.length > 0 ? results[0] : null;
+  }
+  release() {
+    const conn = this.connection;
+    if (conn.release) {
+      conn.release();
+    }
+  }
+  [Symbol.dispose]() {
+    this.release();
+  }
+}
+async function createConnection(config) {
+  const db = new Database(config);
+  await db.connect();
+  return db;
+}
+function sqlFragment(name) {
+  return name.replace(/"/g, '""');
+}
+function buildInClause(values) {
+  const placeholders = values.map(() => "?").join(", ");
+  return {
+    placeholder: `(${placeholders})`,
+    params: values
+  };
+}
+export {
+  sqlFragment,
+  detectDriver,
+  createConnection,
+  buildInClause,
+  ReservedConnection,
+  Database
+};