speexjs 0.2.0

package/dist/server/database/index.js

@@ -0,0 +1,1977 @@
+// src/server/database/connection.ts
+import { randomUUID } from "crypto";
+
+// src/server/database/dialect.ts
+var MysqlDialect = class {
+  wrapIdentifier(identifier) {
+    return `\`${identifier.replace(/`/g, "``")}\``;
+  }
+  makeParameter(_index) {
+    return "?";
+  }
+  compileLimitOffset(bindings, limit, offset) {
+    if (limit === null && offset === null) return "";
+    if (offset !== null) {
+      bindings.push(limit ?? 0, offset);
+      return " LIMIT ? OFFSET ?";
+    }
+    bindings.push(limit);
+    return " LIMIT ?";
+  }
+  compileInsertReturning(sql, _bindings, _idColumn) {
+    return `${sql}; SELECT LAST_INSERT_ID() as id`;
+  }
+  compileTruncate(tableName) {
+    return `TRUNCATE TABLE ${this.wrapIdentifier(tableName)}`;
+  }
+  compileCreateMigrationsTable() {
+    return `CREATE TABLE IF NOT EXISTS \`migrations\` (
+  \`id\` INT AUTO_INCREMENT PRIMARY KEY,
+  \`name\` VARCHAR(255) NOT NULL,
+  \`batch\` INT NOT NULL,
+  \`executed_at\` TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+)`;
+  }
+  mapType(type, options) {
+    switch (type) {
+      case "id":
+      case "increments":
+        return "INT AUTO_INCREMENT PRIMARY KEY";
+      case "bigIncrements":
+        return "BIGINT AUTO_INCREMENT PRIMARY KEY";
+      case "string":
+        return `VARCHAR(${options.length ?? 255})`;
+      case "text":
+        return "TEXT";
+      case "integer":
+        return "INT";
+      case "bigInteger":
+        return "BIGINT";
+      case "tinyInteger":
+        return "TINYINT";
+      case "smallInteger":
+        return "SMALLINT";
+      case "boolean":
+        return "TINYINT(1)";
+      case "float":
+        return "FLOAT";
+      case "double":
+        return "DOUBLE";
+      case "decimal":
+        return `DECIMAL(${options.precision ?? 10},${options.scale ?? 0})`;
+      case "date":
+        return "DATE";
+      case "datetime":
+        return "DATETIME";
+      case "timestamp":
+        return "TIMESTAMP";
+      case "time":
+        return "TIME";
+      case "year":
+        return "YEAR";
+      case "json":
+      case "jsonb":
+        return "JSON";
+      case "binary":
+        return "BLOB";
+      case "uuid":
+        return "CHAR(36)";
+      case "foreignId":
+        return "INT UNSIGNED";
+      default:
+        return type;
+    }
+  }
+  compileColumn(options) {
+    let sql = `${this.wrapIdentifier(options.name)} ${this.mapType(options.type, options)}`;
+    if (options.unsigned && options.type !== "id" && options.type !== "increments" && options.type !== "bigIncrements" && options.type !== "foreignId")
+      sql += " UNSIGNED";
+    if (options.autoIncrement && options.type !== "id" && options.type !== "increments" && options.type !== "bigIncrements")
+      sql += " AUTO_INCREMENT";
+    if (options.defaultValue !== void 0 && options.defaultValue !== null) {
+      sql += ` DEFAULT ${this.formatDefault(options.defaultValue)}`;
+    } else if (!options.nullable && !options.autoIncrement && options.type !== "id" && options.type !== "increments" && options.type !== "bigIncrements") {
+      sql += " NOT NULL";
+    }
+    if (options.nullable) sql += " NULL";
+    if (options.primary) sql += " PRIMARY KEY";
+    if (options.unique) sql += " UNIQUE";
+    if (options.comment !== null)
+      sql += ` COMMENT '${options.comment.replace(/'/g, "\\'")}'`;
+    if (options.after !== null)
+      sql += ` AFTER ${this.wrapIdentifier(options.after)}`;
+    return sql;
+  }
+  compileModifyColumn(options) {
+    return `MODIFY COLUMN ${this.compileColumn(options)}`;
+  }
+  compileTableBlueprint(_tableName, columns, constraints) {
+    const parts = [
+      ...columns.map((c) => this.compileColumn(c)),
+      ...constraints
+    ];
+    return parts.join(",\n  ");
+  }
+  compileAddColumns(_tableName, columns) {
+    return `ADD ${columns.map((c) => this.compileColumn(c)).join(", ADD ")}`;
+  }
+  compileDropColumns(_tableName, columns) {
+    return `DROP COLUMN ${columns.map((c) => this.wrapIdentifier(c)).join(", DROP COLUMN ")}`;
+  }
+  compileRenameColumn(_tableName, from, to) {
+    return `RENAME COLUMN ${this.wrapIdentifier(from)} TO ${this.wrapIdentifier(to)}`;
+  }
+  compileCreateTable(tableName, columns, constraints) {
+    const body = this.compileTableBlueprint(tableName, columns, constraints);
+    return `CREATE TABLE ${this.wrapIdentifier(tableName)} (
+  ${body}
+)`;
+  }
+  compileRenameTable(from, to) {
+    return `RENAME TABLE ${this.wrapIdentifier(from)} TO ${this.wrapIdentifier(to)}`;
+  }
+  compileDropTable(tableName) {
+    return `DROP TABLE ${this.wrapIdentifier(tableName)}`;
+  }
+  compileDropTableIfExists(tableName) {
+    return `DROP TABLE IF EXISTS ${this.wrapIdentifier(tableName)}`;
+  }
+  compileHasTable(_tableName) {
+    return `SELECT COUNT(*) as \`count\` FROM \`information_schema\`.\`tables\` WHERE \`table_schema\` = DATABASE() AND \`table_name\` = ?`;
+  }
+  compileHasColumn(_tableName, _columnName) {
+    return `SELECT COUNT(*) as \`count\` FROM \`information_schema\`.\`columns\` WHERE \`table_schema\` = DATABASE() AND \`table_name\` = ? AND \`column_name\` = ?`;
+  }
+  compileInsert(sql) {
+    return sql;
+  }
+  formatDefault(value) {
+    if (typeof value === "string") {
+      if (value === "CURRENT_TIMESTAMP") return value;
+      return `'${value.replace(/'/g, "\\'")}'`;
+    }
+    if (value === null) return "NULL";
+    if (typeof value === "boolean") return value ? "1" : "0";
+    return String(value);
+  }
+};
+var SqliteDialect = class {
+  wrapIdentifier(identifier) {
+    return `"${identifier.replace(/"/g, '""')}"`;
+  }
+  makeParameter(_index) {
+    return "?";
+  }
+  compileLimitOffset(bindings, limit, offset) {
+    if (limit === null && offset === null) return "";
+    if (offset !== null) {
+      bindings.push(limit ?? 0, offset);
+      return " LIMIT ? OFFSET ?";
+    }
+    bindings.push(limit);
+    return " LIMIT ?";
+  }
+  compileInsertReturning(sql, _bindings, _idColumn) {
+    return `${sql}; SELECT last_insert_rowid() as id`;
+  }
+  compileTruncate(tableName) {
+    return `DELETE FROM ${this.wrapIdentifier(tableName)}`;
+  }
+  compileCreateMigrationsTable() {
+    return `CREATE TABLE IF NOT EXISTS "migrations" (
+  "id" INTEGER PRIMARY KEY AUTOINCREMENT,
+  "name" TEXT NOT NULL,
+  "batch" INTEGER NOT NULL,
+  "executed_at" TEXT DEFAULT CURRENT_TIMESTAMP
+)`;
+  }
+  mapType(type, options) {
+    switch (type) {
+      case "id":
+      case "increments":
+        return "INTEGER PRIMARY KEY AUTOINCREMENT";
+      case "bigIncrements":
+        return "INTEGER PRIMARY KEY AUTOINCREMENT";
+      case "string":
+        return `VARCHAR(${options.length ?? 255})`;
+      case "text":
+        return "TEXT";
+      case "integer":
+        return "INTEGER";
+      case "bigInteger":
+        return "INTEGER";
+      case "tinyInteger":
+        return "INTEGER";
+      case "smallInteger":
+        return "INTEGER";
+      case "boolean":
+        return "INTEGER";
+      case "float":
+        return "REAL";
+      case "double":
+        return "REAL";
+      case "decimal":
+        return "REAL";
+      case "date":
+        return "TEXT";
+      case "datetime":
+        return "TEXT";
+      case "timestamp":
+        return "TEXT";
+      case "time":
+        return "TEXT";
+      case "year":
+        return "TEXT";
+      case "json":
+      case "jsonb":
+        return "TEXT";
+      case "binary":
+        return "BLOB";
+      case "uuid":
+        return "TEXT";
+      case "foreignId":
+        return "INTEGER";
+      default:
+        return type;
+    }
+  }
+  compileColumn(options) {
+    let sql = `${this.wrapIdentifier(options.name)} ${this.mapType(options.type, options)}`;
+    if (options.autoIncrement && options.type !== "id" && options.type !== "increments" && options.type !== "bigIncrements")
+      sql += " AUTOINCREMENT";
+    if (!options.nullable && options.defaultValue === void 0 && !options.autoIncrement && options.type !== "id" && options.type !== "increments" && options.type !== "bigIncrements")
+      sql += " NOT NULL";
+    if (options.nullable) sql += " NULL";
+    if (options.defaultValue !== void 0 && options.defaultValue !== null) {
+      sql += ` DEFAULT ${this.formatDefault(options.defaultValue)}`;
+    }
+    if (options.primary) sql += " PRIMARY KEY";
+    if (options.unique) sql += " UNIQUE";
+    return sql;
+  }
+  compileModifyColumn(options) {
+    return this.compileColumn(options);
+  }
+  compileTableBlueprint(_tableName, columns, constraints) {
+    const parts = [
+      ...columns.map((c) => this.compileColumn(c)),
+      ...constraints
+    ];
+    return parts.join(",\n  ");
+  }
+  compileAddColumns(_tableName, columns) {
+    return `ADD COLUMN ${columns.map((c) => this.compileColumn(c)).join(", ADD COLUMN ")}`;
+  }
+  compileDropColumns(_tableName, columns) {
+    return `DROP COLUMN ${columns.map((c) => this.wrapIdentifier(c)).join(", DROP COLUMN ")}`;
+  }
+  compileRenameColumn(_tableName, from, to) {
+    return `RENAME COLUMN ${this.wrapIdentifier(from)} TO ${this.wrapIdentifier(to)}`;
+  }
+  compileCreateTable(tableName, columns, constraints) {
+    const body = this.compileTableBlueprint(tableName, columns, constraints);
+    return `CREATE TABLE ${this.wrapIdentifier(tableName)} (
+  ${body}
+)`;
+  }
+  compileRenameTable(from, to) {
+    return `ALTER TABLE ${this.wrapIdentifier(from)} RENAME TO ${this.wrapIdentifier(to)}`;
+  }
+  compileDropTable(tableName) {
+    return `DROP TABLE ${this.wrapIdentifier(tableName)}`;
+  }
+  compileDropTableIfExists(tableName) {
+    return `DROP TABLE IF EXISTS ${this.wrapIdentifier(tableName)}`;
+  }
+  compileHasTable(_tableName) {
+    return `SELECT COUNT(*) as "count" FROM "sqlite_master" WHERE "type" = 'table' AND "name" = ?`;
+  }
+  compileHasColumn(_tableName, _columnName) {
+    return `PRAGMA table_info(${this.wrapIdentifier(_tableName)})`;
+  }
+  compileInsert(sql) {
+    return sql;
+  }
+  formatDefault(value) {
+    if (typeof value === "string") {
+      if (value === "CURRENT_TIMESTAMP") return value;
+      return `'${value.replace(/'/g, "''")}'`;
+    }
+    if (value === null) return "NULL";
+    if (typeof value === "boolean") return value ? "1" : "0";
+    return String(value);
+  }
+};
+var PostgresqlDialect = class {
+  wrapIdentifier(identifier) {
+    return `"${identifier.replace(/"/g, '""')}"`;
+  }
+  makeParameter(index) {
+    return `$${index + 1}`;
+  }
+  compileLimitOffset(bindings, limit, offset) {
+    if (limit === null && offset === null) return "";
+    const start = bindings.length;
+    if (offset !== null) {
+      bindings.push(limit ?? 0, offset);
+      return ` LIMIT $${start + 1} OFFSET $${start + 2}`;
+    }
+    bindings.push(limit);
+    return ` LIMIT $${start + 1}`;
+  }
+  compileInsertReturning(sql, _bindings, idColumn = "id") {
+    return `${sql} RETURNING ${this.wrapIdentifier(idColumn)}`;
+  }
+  compileTruncate(tableName) {
+    return `TRUNCATE TABLE ${this.wrapIdentifier(tableName)} RESTART IDENTITY CASCADE`;
+  }
+  compileCreateMigrationsTable() {
+    return `CREATE TABLE IF NOT EXISTS "migrations" (
+  "id" SERIAL PRIMARY KEY,
+  "name" VARCHAR(255) NOT NULL,
+  "batch" INTEGER NOT NULL,
+  "executed_at" TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+)`;
+  }
+  mapType(type, options) {
+    switch (type) {
+      case "id":
+      case "increments":
+        return "SERIAL PRIMARY KEY";
+      case "bigIncrements":
+        return "BIGSERIAL PRIMARY KEY";
+      case "string":
+        return `VARCHAR(${options.length ?? 255})`;
+      case "text":
+        return "TEXT";
+      case "integer":
+        return "INTEGER";
+      case "bigInteger":
+        return "BIGINT";
+      case "tinyInteger":
+        return "SMALLINT";
+      case "smallInteger":
+        return "SMALLINT";
+      case "boolean":
+        return "BOOLEAN";
+      case "float":
+        return "REAL";
+      case "double":
+        return "DOUBLE PRECISION";
+      case "decimal":
+        return `DECIMAL(${options.precision ?? 10},${options.scale ?? 0})`;
+      case "date":
+        return "DATE";
+      case "datetime":
+        return "TIMESTAMP";
+      case "timestamp":
+        return "TIMESTAMP";
+      case "time":
+        return "TIME";
+      case "year":
+        return "INTEGER";
+      case "json":
+        return "JSON";
+      case "jsonb":
+        return "JSONB";
+      case "binary":
+        return "BYTEA";
+      case "uuid":
+        return "UUID";
+      case "foreignId":
+        return "INTEGER";
+      default:
+        return type;
+    }
+  }
+  compileColumn(options) {
+    let sql = `${this.wrapIdentifier(options.name)} ${this.mapType(options.type, options)}`;
+    if (!options.nullable && options.type !== "id" && options.type !== "increments" && options.type !== "bigIncrements")
+      sql += " NOT NULL";
+    if (options.nullable) sql += " NULL";
+    if (options.defaultValue !== void 0 && options.defaultValue !== null) {
+      sql += ` DEFAULT ${this.formatDefault(options.defaultValue)}`;
+    }
+    if (options.primary && options.type !== "id" && options.type !== "increments" && options.type !== "bigIncrements")
+      sql += " PRIMARY KEY";
+    if (options.unique) sql += " UNIQUE";
+    if (options.comment !== null)
+      sql += ` -- ${options.comment.replace(/--/g, "")}`;
+    return sql;
+  }
+  compileModifyColumn(options) {
+    return `ALTER COLUMN ${this.wrapIdentifier(options.name)} TYPE ${this.mapType(options.type, options)}`;
+  }
+  compileTableBlueprint(_tableName, columns, constraints) {
+    const parts = [
+      ...columns.map((c) => this.compileColumn(c)),
+      ...constraints
+    ];
+    return parts.join(",\n  ");
+  }
+  compileAddColumns(_tableName, columns) {
+    return `ADD COLUMN ${columns.map((c) => this.compileColumn(c)).join(", ADD COLUMN ")}`;
+  }
+  compileDropColumns(_tableName, columns) {
+    return `DROP COLUMN ${columns.map((c) => this.wrapIdentifier(c)).join(", DROP COLUMN ")}`;
+  }
+  compileRenameColumn(_tableName, from, to) {
+    return `RENAME COLUMN ${this.wrapIdentifier(from)} TO ${this.wrapIdentifier(to)}`;
+  }
+  compileCreateTable(tableName, columns, constraints) {
+    const body = this.compileTableBlueprint(tableName, columns, constraints);
+    return `CREATE TABLE ${this.wrapIdentifier(tableName)} (
+  ${body}
+)`;
+  }
+  compileRenameTable(from, to) {
+    return `ALTER TABLE ${this.wrapIdentifier(from)} RENAME TO ${this.wrapIdentifier(to)}`;
+  }
+  compileDropTable(_tableName) {
+    return `DROP TABLE IF EXISTS ${this.wrapIdentifier(_tableName)}`;
+  }
+  compileDropTableIfExists(tableName) {
+    return `DROP TABLE IF EXISTS ${this.wrapIdentifier(tableName)}`;
+  }
+  compileHasTable(_tableName) {
+    return `SELECT COUNT(*)::int as "count" FROM "information_schema"."tables" WHERE "table_schema" = 'public' AND "table_name" = $1`;
+  }
+  compileHasColumn(_tableName, _columnName) {
+    return `SELECT COUNT(*)::int as "count" FROM "information_schema"."columns" WHERE "table_schema" = 'public' AND "table_name" = $1 AND "column_name" = $2`;
+  }
+  compileInsert(sql) {
+    return sql;
+  }
+  formatDefault(value) {
+    if (typeof value === "string") {
+      if (value === "CURRENT_TIMESTAMP") return value;
+      return `'${value.replace(/'/g, "''")}'`;
+    }
+    if (value === null) return "NULL";
+    if (typeof value === "boolean") return value ? "true" : "false";
+    return String(value);
+  }
+};
+function createDialect(driver) {
+  switch (driver) {
+    case "mysql":
+      return new MysqlDialect();
+    case "sqlite":
+      return new SqliteDialect();
+    case "postgresql":
+      return new PostgresqlDialect();
+    default:
+      return new MysqlDialect();
+  }
+}
+
+// src/server/database/driver.ts
+async function createDriver(config) {
+  const driverType = config.driver ?? "mysql";
+  switch (driverType) {
+    case "mysql":
+      return createMysqlDriver(config);
+    case "postgresql":
+      return createPostgresqlDriver(config);
+    case "sqlite":
+      return createSqliteDriver(config);
+    default:
+      return createMysqlDriver(config);
+  }
+}
+async function createMysqlDriver(config) {
+  let mysqlPackage;
+  try {
+    mysqlPackage = await import("mysql2/promise");
+  } catch {
+    throw new Error(
+      "MySQL driver (mysql2) is not installed. Run: npm install mysql2"
+    );
+  }
+  let connection = null;
+  const dialect = new MysqlDialect();
+  const driver = {
+    async connect() {
+      connection = await mysqlPackage.createConnection({
+        host: config.host ?? "127.0.0.1",
+        port: config.port ?? 3306,
+        user: config.username,
+        password: config.password,
+        database: config.database,
+        charset: config.charset ?? "utf8mb4"
+      });
+    },
+    async disconnect() {
+      if (connection !== null) {
+        await connection.end();
+        connection = null;
+      }
+    },
+    isConnected() {
+      return connection !== null;
+    },
+    async raw(sql, bindings) {
+      if (connection === null) {
+        throw new Error("Database not connected. Call connect() first.");
+      }
+      const [rows, fields] = await connection.execute(sql, bindings ?? []);
+      return { rows, fields };
+    },
+    async transaction(callback) {
+      if (connection === null) {
+        throw new Error("Database not connected. Call connect() first.");
+      }
+      await connection.beginTransaction();
+      try {
+        const result = await callback(driver);
+        await connection.commit();
+        return result;
+      } catch (err) {
+        await connection.rollback();
+        throw err;
+      }
+    },
+    getDialect() {
+      return dialect;
+    },
+    getDriver() {
+      return "mysql";
+    }
+  };
+  return driver;
+}
+async function createPostgresqlDriver(config) {
+  let pgPackage;
+  try {
+    pgPackage = await import("pg");
+  } catch {
+    throw new Error(
+      "PostgreSQL driver (pg) is not installed. Run: npm install pg"
+    );
+  }
+  let pool = null;
+  const dialect = new PostgresqlDialect();
+  const driver = {
+    async connect() {
+      const { Pool } = pgPackage;
+      pool = new Pool({
+        host: config.host ?? "127.0.0.1",
+        port: config.port ?? 5432,
+        user: config.username,
+        password: config.password,
+        database: config.database
+      });
+      await pool.query("SELECT 1");
+    },
+    async disconnect() {
+      if (pool !== null) {
+        await pool.end();
+        pool = null;
+      }
+    },
+    isConnected() {
+      return pool !== null;
+    },
+    async raw(sql, bindings) {
+      if (pool === null) {
+        throw new Error("Database not connected. Call connect() first.");
+      }
+      const result = await pool.query(sql, bindings ?? []);
+      return { rows: result.rows };
+    },
+    async transaction(callback) {
+      if (pool === null) {
+        throw new Error("Database not connected. Call connect() first.");
+      }
+      const client = await pool.connect();
+      try {
+        await client.query("BEGIN");
+        const trxDriver = {
+          ...driver,
+          async raw(sql, bindings) {
+            const result2 = await client.query(sql, bindings ?? []);
+            return { rows: result2.rows };
+          },
+          getDialect() {
+            return dialect;
+          },
+          getDriver() {
+            return "postgresql";
+          }
+        };
+        const result = await callback(trxDriver);
+        await client.query("COMMIT");
+        return result;
+      } catch (err) {
+        await client.query("ROLLBACK");
+        throw err;
+      } finally {
+        client.release();
+      }
+    },
+    getDialect() {
+      return dialect;
+    },
+    getDriver() {
+      return "postgresql";
+    }
+  };
+  return driver;
+}
+async function createSqliteDriver(config) {
+  let sqlitePackage;
+  try {
+    sqlitePackage = await import("better-sqlite3");
+  } catch {
+    throw new Error(
+      "SQLite driver (better-sqlite3) is not installed. Run: npm install better-sqlite3"
+    );
+  }
+  let db = null;
+  let connected = false;
+  const dialect = new SqliteDialect();
+  const driver = {
+    async connect() {
+      db = new sqlitePackage(config.database);
+      db.pragma("journal_mode = WAL");
+      connected = true;
+    },
+    async disconnect() {
+      if (db !== null) {
+        db.close();
+        db = null;
+        connected = false;
+      }
+    },
+    isConnected() {
+      return connected;
+    },
+    async raw(sql, bindings) {
+      if (db === null) {
+        throw new Error("Database not connected. Call connect() first.");
+      }
+      const trimmedSQL = sql.trim().toUpperCase();
+      const isQuery = trimmedSQL.startsWith("SELECT") || trimmedSQL.startsWith("WITH") || trimmedSQL.startsWith("PRAGMA");
+      const stmt = db.prepare(sql);
+      if (isQuery) {
+        const rows = bindings !== void 0 && bindings.length > 0 ? stmt.all(...bindings) : stmt.all();
+        return { rows };
+      }
+      if (bindings !== void 0 && bindings.length > 0) {
+        stmt.run(...bindings);
+      } else {
+        stmt.run();
+      }
+      return { rows: [] };
+    },
+    async transaction(callback) {
+      if (db === null) {
+        throw new Error("Database not connected. Call connect() first.");
+      }
+      const txn = db.transaction(async () => {
+        return await callback(driver);
+      });
+      return txn();
+    },
+    getDialect() {
+      return dialect;
+    },
+    getDriver() {
+      return "sqlite";
+    }
+  };
+  return driver;
+}
+
+// src/server/database/query.ts
+var QueryBuilder = class _QueryBuilder {
+  connection;
+  tableName;
+  columns = ["*"];
+  distinctEnabled = false;
+  wheres = [];
+  joins = [];
+  orderBys = [];
+  havings = [];
+  groupBys = [];
+  limitValue = null;
+  offsetValue = null;
+  fromSubquery = null;
+  constructor(connection, tableName) {
+    this.connection = connection;
+    this.tableName = tableName;
+  }
+  select(...columns) {
+    this.columns = columns.length > 0 ? columns : ["*"];
+    return this;
+  }
+  addSelect(...columns) {
+    if (this.columns[0] === "*") {
+      this.columns = columns;
+    } else {
+      this.columns.push(...columns);
+    }
+    return this;
+  }
+  distinct() {
+    this.distinctEnabled = true;
+    return this;
+  }
+  from(table) {
+    this.fromSubquery = table;
+    return this;
+  }
+  where(column, operator, value) {
+    if (value === void 0) {
+      value = operator;
+      operator = "=";
+    }
+    this.wheres.push({
+      type: "basic",
+      column,
+      operator: String(operator),
+      value,
+      boolean: "and"
+    });
+    return this;
+  }
+  orWhere(column, operator, value) {
+    if (value === void 0) {
+      value = operator;
+      operator = "=";
+    }
+    this.wheres.push({
+      type: "basic",
+      column,
+      operator: String(operator),
+      value,
+      boolean: "or"
+    });
+    return this;
+  }
+  whereIn(column, values) {
+    this.wheres.push({ type: "in", column, values, boolean: "and" });
+    return this;
+  }
+  whereNotIn(column, values) {
+    this.wheres.push({ type: "notIn", column, values, boolean: "and" });
+    return this;
+  }
+  whereNull(column) {
+    this.wheres.push({ type: "null", column, boolean: "and" });
+    return this;
+  }
+  whereNotNull(column) {
+    this.wheres.push({ type: "notNull", column, boolean: "and" });
+    return this;
+  }
+  whereBetween(column, range) {
+    this.wheres.push({
+      type: "between",
+      column,
+      values: range,
+      boolean: "and"
+    });
+    return this;
+  }
+  whereNotBetween(column, range) {
+    this.wheres.push({
+      type: "notBetween",
+      column,
+      values: range,
+      boolean: "and"
+    });
+    return this;
+  }
+  whereLike(column, pattern) {
+    this.wheres.push({ type: "like", column, value: pattern, boolean: "and" });
+    return this;
+  }
+  orWhereLike(column, pattern) {
+    this.wheres.push({ type: "like", column, value: pattern, boolean: "or" });
+    return this;
+  }
+  whereGroup(callback) {
+    const subQuery = new _QueryBuilder(this.connection, this.tableName);
+    callback(subQuery);
+    this.wheres.push({
+      type: "nested",
+      nested: subQuery.wheres,
+      boolean: "and"
+    });
+    return this;
+  }
+  join(table, first, operator, second, type = "inner") {
+    this.joins.push({ table, first, operator, second, type });
+    return this;
+  }
+  leftJoin(table, first, operator, second) {
+    return this.join(table, first, operator, second, "left");
+  }
+  rightJoin(table, first, operator, second) {
+    return this.join(table, first, operator, second, "right");
+  }
+  crossJoin(table, first, operator, second) {
+    return this.join(table, first, operator, second, "cross");
+  }
+  orderBy(column, direction = "asc") {
+    this.orderBys.push({ column, direction });
+    return this;
+  }
+  orderByDesc(column) {
+    return this.orderBy(column, "desc");
+  }
+  latest(column = "created_at") {
+    return this.orderBy(column, "desc");
+  }
+  oldest(column = "created_at") {
+    return this.orderBy(column, "asc");
+  }
+  inRandomOrder() {
+    this.orderBys.push({ column: "RANDOM()", direction: "asc" });
+    return this;
+  }
+  limit(limit) {
+    this.limitValue = limit;
+    return this;
+  }
+  offset(offset) {
+    this.offsetValue = offset;
+    return this;
+  }
+  skip(skip) {
+    return this.offset(skip);
+  }
+  take(take) {
+    return this.limit(take);
+  }
+  groupBy(...columns) {
+    this.groupBys.push(...columns);
+    return this;
+  }
+  having(column, operator, value) {
+    this.havings.push({ column, operator, value });
+    return this;
+  }
+  async get() {
+    const { sql, bindings } = this.toSQL();
+    const result = await this.connection.raw(sql, bindings);
+    return result.rows;
+  }
+  async first() {
+    const qb = this.clone();
+    qb.limitValue = 1;
+    const { sql, bindings } = qb.toSQL();
+    const result = await this.connection.raw(sql, bindings);
+    return result.rows.length > 0 ? result.rows[0] : null;
+  }
+  async find(id) {
+    return this.where("id", id).first();
+  }
+  async pluck(column) {
+    const qb = this.clone();
+    qb.columns = [column];
+    const { sql, bindings } = qb.toSQL();
+    const result = await this.connection.raw(sql, bindings);
+    return result.rows.map((row) => row[column]);
+  }
+  async count(column = "*") {
+    const qb = this.clone();
+    qb.columns = [
+      `COUNT(${column === "*" ? "*" : this.wrap(column)}) as aggregate`
+    ];
+    qb.orderBys = [];
+    qb.limitValue = null;
+    qb.offsetValue = null;
+    const { sql, bindings } = qb.toSQL();
+    const result = await this.connection.raw(sql, bindings);
+    const row = result.rows[0];
+    if (!row) return 0;
+    return Number(row.aggregate ?? row.count ?? row["COUNT(*)"] ?? 0);
+  }
+  async exists() {
+    const count = await this.count();
+    return count > 0;
+  }
+  async doesntExist() {
+    return !await this.exists();
+  }
+  async max(column) {
+    return this.aggregate("MAX", column);
+  }
+  async min(column) {
+    return this.aggregate("MIN", column);
+  }
+  async sum(column) {
+    const result = await this.aggregate("SUM", column);
+    return result ?? 0;
+  }
+  async avg(column) {
+    const result = await this.aggregate("AVG", column);
+    return result ?? 0;
+  }
+  async paginate(perPage = 15, page = 1) {
+    const countQb = this.clone();
+    const total = await countQb.count();
+    const lastPage = Math.max(1, Math.ceil(total / perPage));
+    const currentPage = Math.max(1, Math.min(page, lastPage));
+    const fromVal = (currentPage - 1) * perPage + 1;
+    const toVal = Math.min(currentPage * perPage, total);
+    const qb = this.clone();
+    qb.limitValue = perPage;
+    qb.offsetValue = (currentPage - 1) * perPage;
+    const { sql, bindings } = qb.toSQL();
+    const result = await this.connection.raw(sql, bindings);
+    return {
+      data: result.rows,
+      currentPage,
+      perPage,
+      total,
+      lastPage,
+      from: total > 0 ? fromVal : 0,
+      to: total > 0 ? toVal : 0,
+      hasMore: currentPage < lastPage,
+      hasPrev: currentPage > 1,
+      isEmpty: total === 0
+    };
+  }
+  async insert(data) {
+    const { sql, bindings } = this.compileInsert(data);
+    const driverType = this.connection.getDriver();
+    if (driverType === "postgresql") {
+      const dialect = this.connection.getDialect();
+      const returningSQL = dialect.compileInsertReturning(sql, bindings);
+      const result2 = await this.connection.raw(returningSQL, bindings);
+      return result2.rows.length > 0 ? Number(result2.rows[0].id) ?? 0 : 0;
+    }
+    const result = await this.connection.raw(sql, bindings);
+    if (result.rows && result.rows.length > 0) {
+      return Number(result.rows[0].id) ?? result.rows[0].insertId ?? 0;
+    }
+    return 0;
+  }
+  async insertGetId(data) {
+    return this.insert(data);
+  }
+  async insertReturning(data) {
+    const { sql, bindings } = this.compileInsert(data);
+    const dialect = this.connection.getDialect();
+    const returningSQL = dialect.compileInsertReturning(sql, bindings);
+    const result = await this.connection.raw(returningSQL, bindings);
+    return result.rows.length > 0 ? result.rows[0] : null;
+  }
+  async update(data) {
+    const { sql, bindings } = this.compileUpdate(data);
+    const result = await this.connection.raw(sql, bindings);
+    const rows = result.rows;
+    if (rows.length > 0) {
+      const info = rows[0];
+      return info.affectedRows ?? info.changes ?? rows.length;
+    }
+    return 0;
+  }
+  async delete() {
+    const { sql, bindings } = this.compileDelete();
+    const result = await this.connection.raw(sql, bindings);
+    const rows = result.rows;
+    if (rows.length > 0) {
+      const info = rows[0];
+      return info.affectedRows ?? info.changes ?? rows.length;
+    }
+    return 0;
+  }
+  async truncate() {
+    const dialect = this.connection.getDialect();
+    const sql = dialect.compileTruncate(this.tableName);
+    await this.connection.raw(sql);
+  }
+  async chunk(size, callback) {
+    let page = 1;
+    let hasMore = true;
+    while (hasMore) {
+      const qb = this.clone();
+      qb.limitValue = size;
+      qb.offsetValue = (page - 1) * size;
+      const rows = await qb.get();
+      if (rows.length === 0) {
+        hasMore = false;
+        break;
+      }
+      await callback(rows);
+      if (rows.length < size) {
+        hasMore = false;
+      }
+      page++;
+    }
+  }
+  clone() {
+    const qb = new _QueryBuilder(this.connection, this.tableName);
+    qb.columns = [...this.columns];
+    qb.distinctEnabled = this.distinctEnabled;
+    qb.wheres = this.cloneWheres(this.wheres);
+    qb.joins = [...this.joins];
+    qb.orderBys = [...this.orderBys];
+    qb.havings = [...this.havings];
+    qb.groupBys = [...this.groupBys];
+    qb.limitValue = this.limitValue;
+    qb.offsetValue = this.offsetValue;
+    qb.fromSubquery = this.fromSubquery;
+    return qb;
+  }
+  toSQL() {
+    const bindings = [];
+    const dialect = this.connection.getDialect();
+    const wrappedColumns = this.columns.map(
+      (c) => c.includes("(") || c === "*" || c.includes(" as ") || c.includes(" AS ") ? c : dialect.wrapIdentifier(c)
+    ).join(", ");
+    const from = this.fromSubquery ?? this.tableName;
+    const wrappedFrom = this.fromSubquery ?? dialect.wrapIdentifier(from);
+    let sql = this.distinctEnabled ? `SELECT DISTINCT ${wrappedColumns} FROM ${wrappedFrom}` : `SELECT ${wrappedColumns} FROM ${wrappedFrom}`;
+    const joinSQL = this.compileJoins(dialect);
+    if (joinSQL) sql += joinSQL;
+    const whereSQL = this.compileWheres(dialect, bindings);
+    if (whereSQL) sql += whereSQL;
+    if (this.groupBys.length > 0) {
+      sql += ` GROUP BY ${this.groupBys.map((c) => dialect.wrapIdentifier(c)).join(", ")}`;
+    }
+    const havingSQL = this.compileHavings(dialect, bindings);
+    if (havingSQL) sql += havingSQL;
+    if (this.orderBys.length > 0) {
+      sql += ` ORDER BY ${this.orderBys.map((o) => {
+        const col = o.column === "RANDOM()" ? o.column : dialect.wrapIdentifier(o.column);
+        return `${col} ${o.direction.toUpperCase()}`;
+      }).join(", ")}`;
+    }
+    const limitOffsetSQL = dialect.compileLimitOffset(
+      bindings,
+      this.limitValue,
+      this.offsetValue
+    );
+    if (limitOffsetSQL) sql += limitOffsetSQL;
+    return { sql, bindings };
+  }
+  dd() {
+    const { sql, bindings } = this.toSQL();
+    const output = `SQL: ${sql}
+Bindings: ${JSON.stringify(bindings)}`;
+    console.error(output);
+    process.exit(1);
+  }
+  compileJoins(dialect) {
+    if (this.joins.length === 0) return "";
+    return " " + this.joins.map((j) => {
+      const type = j.type.toUpperCase();
+      return `${type} JOIN ${dialect.wrapIdentifier(j.table)} ON ${dialect.wrapIdentifier(j.first)} ${j.operator} ${this.wrap(j.second)}`;
+    }).join(" ");
+  }
+  compileWheres(dialect, bindings) {
+    if (this.wheres.length === 0) return "";
+    const sql = this.compileWhereArray(this.wheres, dialect, bindings);
+    return sql ? ` WHERE ${sql}` : "";
+  }
+  compileWhereArray(wheres, dialect, bindings) {
+    if (wheres.length === 0) return "";
+    const parts = [];
+    for (const w of wheres) {
+      const sql = this.compileSingleWhere(w, dialect, bindings);
+      if (sql !== null) parts.push(sql);
+    }
+    if (parts.length === 0) return "";
+    return parts.join(" AND ");
+  }
+  compileSingleWhere(w, dialect, bindings) {
+    const col = w.column ? dialect.wrapIdentifier(w.column) : "";
+    switch (w.type) {
+      case "basic": {
+        bindings.push(w.value);
+        const operator = w.operator === "=" ? "=" : w.operator;
+        return `${col} ${operator} ${dialect.makeParameter(bindings.length - 1)}`;
+      }
+      case "in": {
+        const placeholders = w.values.map((v) => {
+          bindings.push(v);
+          return dialect.makeParameter(bindings.length - 1);
+        }).join(", ");
+        return `${col} IN (${placeholders})`;
+      }
+      case "notIn": {
+        const placeholders = w.values.map((v) => {
+          bindings.push(v);
+          return dialect.makeParameter(bindings.length - 1);
+        }).join(", ");
+        return `${col} NOT IN (${placeholders})`;
+      }
+      case "null":
+        return `${col} IS NULL`;
+      case "notNull":
+        return `${col} IS NOT NULL`;
+      case "between": {
+        bindings.push(w.values[0], w.values[1]);
+        return `${col} BETWEEN ${dialect.makeParameter(bindings.length - 2)} AND ${dialect.makeParameter(bindings.length - 1)}`;
+      }
+      case "notBetween": {
+        bindings.push(w.values[0], w.values[1]);
+        return `${col} NOT BETWEEN ${dialect.makeParameter(bindings.length - 2)} AND ${dialect.makeParameter(bindings.length - 1)}`;
+      }
+      case "like": {
+        bindings.push(w.value);
+        return `${col} LIKE ${dialect.makeParameter(bindings.length - 1)}`;
+      }
+      case "nested": {
+        const nestedSQL = this.compileNestedWhere(w.nested, dialect, bindings);
+        return nestedSQL ? `(${nestedSQL})` : null;
+      }
+      default:
+        return null;
+    }
+  }
+  compileNestedWhere(wheres, dialect, bindings) {
+    const parts = [];
+    for (const w of wheres) {
+      const sql = this.compileSingleWhere(w, dialect, bindings);
+      if (sql !== null) {
+        parts.push(sql);
+      }
+    }
+    if (parts.length === 0) return "";
+    return parts.join(" AND ");
+  }
+  compileHavings(dialect, bindings) {
+    if (this.havings.length === 0) return "";
+    const parts = this.havings.map((h) => {
+      bindings.push(h.value);
+      return `${dialect.wrapIdentifier(h.column)} ${h.operator} ${dialect.makeParameter(bindings.length - 1)}`;
+    });
+    return ` HAVING ${parts.join(" AND ")}`;
+  }
+  compileInsert(data) {
+    const dialect = this.connection.getDialect();
+    const columns = Object.keys(data);
+    const values = Object.values(data);
+    const bindings = [];
+    const placeholders = values.map((v) => {
+      bindings.push(v);
+      return dialect.makeParameter(bindings.length - 1);
+    }).join(", ");
+    const sql = `INSERT INTO ${dialect.wrapIdentifier(this.tableName)} (${columns.map((c) => dialect.wrapIdentifier(c)).join(", ")}) VALUES (${placeholders})`;
+    return { sql, bindings };
+  }
+  compileUpdate(data) {
+    const dialect = this.connection.getDialect();
+    const bindings = [];
+    const sets = Object.entries(data).map(([key, value]) => {
+      bindings.push(value);
+      return `${dialect.wrapIdentifier(key)} = ${dialect.makeParameter(bindings.length - 1)}`;
+    });
+    let sql = `UPDATE ${dialect.wrapIdentifier(this.tableName)} SET ${sets.join(", ")}`;
+    const whereSQL = this.compileWheres(dialect, bindings);
+    if (whereSQL) sql += whereSQL;
+    if (this.orderBys.length > 0) {
+      sql += ` ORDER BY ${this.orderBys.map((o) => {
+        const col = o.column === "RANDOM()" ? o.column : dialect.wrapIdentifier(o.column);
+        return `${col} ${o.direction.toUpperCase()}`;
+      }).join(", ")}`;
+    }
+    const limitOffsetSQL = dialect.compileLimitOffset(
+      bindings,
+      this.limitValue,
+      this.offsetValue
+    );
+    if (limitOffsetSQL) sql += limitOffsetSQL;
+    return { sql, bindings };
+  }
+  compileDelete() {
+    const dialect = this.connection.getDialect();
+    const bindings = [];
+    let sql = `DELETE FROM ${dialect.wrapIdentifier(this.tableName)}`;
+    const whereSQL = this.compileWheres(dialect, bindings);
+    if (whereSQL) sql += whereSQL;
+    if (this.orderBys.length > 0) {
+      sql += ` ORDER BY ${this.orderBys.map((o) => {
+        const col = o.column === "RANDOM()" ? o.column : dialect.wrapIdentifier(o.column);
+        return `${col} ${o.direction.toUpperCase()}`;
+      }).join(", ")}`;
+    }
+    const limitOffsetSQL = dialect.compileLimitOffset(
+      bindings,
+      this.limitValue,
+      this.offsetValue
+    );
+    if (limitOffsetSQL) sql += limitOffsetSQL;
+    return { sql, bindings };
+  }
+  async aggregate(fn, column) {
+    const qb = this.clone();
+    qb.columns = [`${fn}(${this.wrap(column)}) as aggregate`];
+    qb.orderBys = [];
+    qb.limitValue = null;
+    qb.offsetValue = null;
+    const { sql, bindings } = qb.toSQL();
+    const result = await this.connection.raw(sql, bindings);
+    const row = result.rows[0];
+    if (!row) return null;
+    const val = row.aggregate ?? row[`${fn}(${column})`];
+    return val !== null && val !== void 0 ? Number(val) : null;
+  }
+  cloneWheres(wheres) {
+    return wheres.map((w) => ({
+      ...w,
+      values: w.values ? [...w.values] : void 0,
+      nested: w.nested ? this.cloneWheres(w.nested) : void 0
+    }));
+  }
+  wrap(identifier) {
+    if (identifier === "*" || identifier.includes("(")) return identifier;
+    const dialect = this.connection.getDialect();
+    return dialect.wrapIdentifier(identifier);
+  }
+};
+
+// src/server/database/connection.ts
+var DatabaseConnection = class _DatabaseConnection {
+  config;
+  driver = null;
+  constructor(config) {
+    this.config = {
+      driver: "mysql",
+      host: "127.0.0.1",
+      charset: "utf8mb4",
+      prefix: "",
+      ...config
+    };
+    if (this.config.port === void 0) {
+      if (this.config.driver === "mysql") this.config.port = 3306;
+      else if (this.config.driver === "postgresql") this.config.port = 5432;
+    }
+  }
+  async connect() {
+    if (this.driver !== null) return;
+    this.driver = await createDriver(this.config);
+    await this.driver.connect();
+  }
+  async disconnect() {
+    if (this.driver !== null) {
+      await this.driver.disconnect();
+      this.driver = null;
+    }
+  }
+  async raw(sql, bindings) {
+    this.ensureConnected();
+    return this.driver.raw(sql, bindings);
+  }
+  table(tableName) {
+    return new QueryBuilder(this, `${this.config.prefix ?? ""}${tableName}`);
+  }
+  isConnected() {
+    return this.driver !== null && this.driver.isConnected();
+  }
+  getDriver() {
+    return this.config.driver ?? "mysql";
+  }
+  getDialect() {
+    this.ensureConnected();
+    return this.driver.getDialect();
+  }
+  getPrefix() {
+    return this.config.prefix ?? "";
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  async transaction(callback) {
+    this.ensureConnected();
+    return this.driver.transaction(async (_driver) => {
+      const trxConnection = new _DatabaseConnection(this.config);
+      trxConnection["driver"] = this.driver;
+      trxConnection.raw = async (sql, bindings) => {
+        return this.driver.raw(sql, bindings);
+      };
+      return callback(trxConnection);
+    });
+  }
+  static generateId() {
+    return randomUUID();
+  }
+  ensureConnected() {
+    if (this.driver === null || !this.driver.isConnected()) {
+      throw new Error(
+        "Database not connected. Call connect() before performing operations."
+      );
+    }
+  }
+};
+
+// src/server/database/migration.ts
+var SchemaBuilder = class {
+  connection;
+  constructor(connection) {
+    this.connection = connection;
+  }
+  async createTable(tableName, callback) {
+    const blueprint = new TableBlueprint(this.connection, "create");
+    callback(blueprint);
+    const dialect = this.connection.getDialect();
+    const columns = blueprint.compileColumns();
+    const constraints = blueprint.compileConstraints(dialect);
+    const sql = dialect.compileCreateTable(tableName, columns, constraints);
+    await this.connection.raw(sql);
+  }
+  async dropTable(tableName) {
+    const dialect = this.connection.getDialect();
+    const sql = dialect.compileDropTable(tableName);
+    await this.connection.raw(sql);
+  }
+  async dropTableIfExists(tableName) {
+    const dialect = this.connection.getDialect();
+    const sql = dialect.compileDropTableIfExists(tableName);
+    await this.connection.raw(sql);
+  }
+  async renameTable(from, to) {
+    const dialect = this.connection.getDialect();
+    const sql = dialect.compileRenameTable(from, to);
+    await this.connection.raw(sql);
+  }
+  async alterTable(tableName, callback) {
+    const blueprint = new TableBlueprint(this.connection, "alter");
+    callback(blueprint);
+    const dialect = this.connection.getDialect();
+    if (blueprint.droppedColumns.length > 0) {
+      const dropSQL = dialect.compileDropColumns(
+        tableName,
+        blueprint.droppedColumns
+      );
+      await this.connection.raw(
+        `ALTER TABLE ${dialect.wrapIdentifier(tableName)} ${dropSQL}`
+      );
+    }
+    if (blueprint.renamedColumns.length > 0) {
+      for (const { from, to } of blueprint.renamedColumns) {
+        const renameSQL = dialect.compileRenameColumn(tableName, from, to);
+        await this.connection.raw(
+          `ALTER TABLE ${dialect.wrapIdentifier(tableName)} ${renameSQL}`
+        );
+      }
+    }
+    const compiledColumns = blueprint.compileColumnDefinitions(dialect);
+    if (compiledColumns.length > 0) {
+      for (const colSQL of compiledColumns) {
+        await this.connection.raw(
+          `ALTER TABLE ${dialect.wrapIdentifier(tableName)} ${colSQL}`
+        );
+      }
+    }
+  }
+  async hasTable(tableName) {
+    const dialect = this.connection.getDialect();
+    const sql = dialect.compileHasTable(tableName);
+    const result = await this.connection.raw(sql, [tableName]);
+    return this.parseCount(result) > 0;
+  }
+  async hasColumn(tableName, columnName) {
+    const dialect = this.connection.getDialect();
+    const driver = this.connection.getDriver();
+    if (driver === "sqlite") {
+      const sql2 = dialect.compileHasColumn(tableName, columnName);
+      const result2 = await this.connection.raw(sql2);
+      return result2.rows.some((row) => row.name === columnName);
+    }
+    const sql = dialect.compileHasColumn(tableName, columnName);
+    const result = await this.connection.raw(sql, [tableName, columnName]);
+    return this.parseCount(result) > 0;
+  }
+  parseCount(result) {
+    if (result.rows.length === 0) return 0;
+    const row = result.rows[0];
+    return Number(row.count ?? row.Count ?? 0);
+  }
+};
+var TableBlueprint = class {
+  mode;
+  columns = [];
+  primaryKeys = [];
+  uniqueKeys = [];
+  indexKeys = [];
+  foreignKeys = [];
+  droppedColumns = [];
+  renamedColumns = [];
+  constructor(_connection, mode) {
+    this.mode = mode;
+  }
+  id(name = "id") {
+    const col = this.addColumn("id", name);
+    col.autoIncrement();
+    col.unsigned();
+    return col;
+  }
+  increments(name = "id") {
+    const col = this.addColumn("increments", name);
+    col.autoIncrement();
+    col.unsigned();
+    return col;
+  }
+  bigIncrements(name = "id") {
+    const col = this.addColumn("bigIncrements", name);
+    col.autoIncrement();
+    col.unsigned();
+    return col;
+  }
+  string(name, length = 255) {
+    const col = this.addColumn("string", name);
+    col.setLength(length);
+    return col;
+  }
+  text(name) {
+    return this.addColumn("text", name);
+  }
+  integer(name) {
+    return this.addColumn("integer", name);
+  }
+  bigInteger(name) {
+    return this.addColumn("bigInteger", name);
+  }
+  tinyInteger(name) {
+    return this.addColumn("tinyInteger", name);
+  }
+  smallInteger(name) {
+    return this.addColumn("smallInteger", name);
+  }
+  boolean(name) {
+    return this.addColumn("boolean", name);
+  }
+  float(name, _precision) {
+    const col = this.addColumn("float", name);
+    if (_precision !== void 0) col.setPrecision(_precision);
+    return col;
+  }
+  double(name) {
+    return this.addColumn("double", name);
+  }
+  decimal(name, precision = 10, scale = 0) {
+    const col = this.addColumn("decimal", name);
+    col.setPrecision(precision);
+    col.setScale(scale);
+    return col;
+  }
+  date(name) {
+    return this.addColumn("date", name);
+  }
+  datetime(name) {
+    return this.addColumn("datetime", name);
+  }
+  timestamp(name) {
+    return this.addColumn("timestamp", name);
+  }
+  time(name) {
+    return this.addColumn("time", name);
+  }
+  year(name) {
+    return this.addColumn("year", name);
+  }
+  json(name) {
+    return this.addColumn("json", name);
+  }
+  jsonb(name) {
+    return this.addColumn("jsonb", name);
+  }
+  binary(name) {
+    return this.addColumn("binary", name);
+  }
+  uuid(name = "uuid") {
+    return this.addColumn("uuid", name);
+  }
+  enum(name, values) {
+    const col = this.addColumn("enum", name);
+    col.setValues(values);
+    return col;
+  }
+  foreignId(name) {
+    const col = this.addColumn("foreignId", name);
+    col.unsigned();
+    return col;
+  }
+  primary(...columns) {
+    this.primaryKeys.push(...columns);
+  }
+  unique(...columns) {
+    this.uniqueKeys.push(columns);
+  }
+  index(...columns) {
+    this.indexKeys.push(columns);
+  }
+  foreign(column) {
+    const fk = {
+      column,
+      references: "",
+      on: "",
+      onDelete: null,
+      onUpdate: null
+    };
+    this.foreignKeys.push(fk);
+    return new ForeignKeyDefinition(fk);
+  }
+  timestamps() {
+    this.timestamp("created_at").nullable();
+    this.timestamp("updated_at").nullable();
+  }
+  softDeletes() {
+    this.timestamp("deleted_at").nullable();
+  }
+  rememberToken() {
+    this.string("remember_token", 100).nullable();
+  }
+  dropColumn(column) {
+    this.droppedColumns.push(column);
+  }
+  renameColumn(from, to) {
+    this.renamedColumns.push({ from, to });
+  }
+  dropPrimary() {
+    this.primaryKeys = [];
+  }
+  dropUnique(_indexName) {
+    this.uniqueKeys = [];
+  }
+  dropIndex(_indexName) {
+    this.indexKeys = [];
+  }
+  dropForeign(_indexName) {
+    this.foreignKeys = [];
+  }
+  dropTimestamps() {
+    this.droppedColumns.push("created_at", "updated_at");
+  }
+  dropSoftDeletes() {
+    this.droppedColumns.push("deleted_at");
+  }
+  dropRememberToken() {
+    this.droppedColumns.push("remember_token");
+  }
+  compileColumns() {
+    return this.columns.filter((c) => this.mode === "create" || c.isNew).map((c) => c.compile());
+  }
+  compileConstraints(dialect) {
+    const constraints = [];
+    const wrap = (name) => dialect.wrapIdentifier(name);
+    for (const pk of this.primaryKeys) {
+      constraints.push(`PRIMARY KEY (${wrap(pk)})`);
+    }
+    for (const uk of this.uniqueKeys) {
+      constraints.push(`UNIQUE (${uk.map((c) => wrap(c)).join(", ")})`);
+    }
+    for (const ik of this.indexKeys) {
+      constraints.push(`INDEX (${ik.map((c) => wrap(c)).join(", ")})`);
+    }
+    for (const fk of this.foreignKeys) {
+      let fkSQL = `FOREIGN KEY (${wrap(fk.column)}) REFERENCES ${wrap(fk.on)} (${wrap(fk.references)})`;
+      if (fk.onDelete) fkSQL += ` ON DELETE ${fk.onDelete}`;
+      if (fk.onUpdate) fkSQL += ` ON UPDATE ${fk.onUpdate}`;
+      constraints.push(fkSQL);
+    }
+    return constraints;
+  }
+  compileColumnDefinitions(dialect) {
+    return this.columns.filter((c) => c.isNew && this.mode === "alter").map((c) => dialect.compileAddColumns("", [c.compile()]));
+  }
+  addColumn(type, name) {
+    const col = new ColumnDefinition(type, name);
+    this.columns.push(col);
+    return col;
+  }
+};
+var ColumnDefinition = class {
+  type;
+  name;
+  isNullable = false;
+  defaultValue = void 0;
+  isUnsigned = false;
+  isUnique = false;
+  isPrimary = false;
+  isIndex = false;
+  commentText = null;
+  afterColumn = null;
+  isFirst = false;
+  isAutoIncrement = false;
+  precisionValue = null;
+  scaleValue = null;
+  lengthValue = null;
+  enumValues = null;
+  isForeignId = false;
+  isNew = true;
+  constructor(type, name) {
+    this.type = type;
+    this.name = name;
+  }
+  nullable() {
+    this.isNullable = true;
+    return this;
+  }
+  default(value) {
+    this.defaultValue = value;
+    return this;
+  }
+  unsigned() {
+    this.isUnsigned = true;
+    return this;
+  }
+  unique() {
+    this.isUnique = true;
+    return this;
+  }
+  primary() {
+    this.isPrimary = true;
+    return this;
+  }
+  index() {
+    this.isIndex = true;
+    return this;
+  }
+  comment(text) {
+    this.commentText = text;
+    return this;
+  }
+  after(column) {
+    this.afterColumn = column;
+    return this;
+  }
+  first() {
+    this.isFirst = true;
+    return this;
+  }
+  autoIncrement() {
+    this.isAutoIncrement = true;
+    return this;
+  }
+  setValues(vals) {
+    this.enumValues = vals;
+    return this;
+  }
+  setLength(len) {
+    this.lengthValue = len;
+    return this;
+  }
+  setPrecision(precision) {
+    this.precisionValue = precision;
+    return this;
+  }
+  setScale(scale) {
+    this.scaleValue = scale;
+    return this;
+  }
+  compile() {
+    return {
+      name: this.name,
+      type: this.type,
+      nullable: this.isNullable,
+      defaultValue: this.defaultValue,
+      unsigned: this.isUnsigned,
+      unique: this.isUnique,
+      primary: this.isPrimary,
+      index: this.isIndex,
+      comment: this.commentText,
+      after: this.afterColumn,
+      first: this.isFirst,
+      autoIncrement: this.isAutoIncrement,
+      precision: this.precisionValue,
+      scale: this.scaleValue,
+      length: this.lengthValue,
+      values: this.enumValues,
+      isForeignId: this.isForeignId
+    };
+  }
+};
+var ForeignKeyDefinition = class {
+  def;
+  constructor(def) {
+    this.def = def;
+  }
+  references(column) {
+    this.def.references = column;
+    return this;
+  }
+  on(table) {
+    this.def.on = table;
+    return this;
+  }
+  onDelete(action) {
+    this.def.onDelete = action;
+    return this;
+  }
+  onUpdate(action) {
+    this.def.onUpdate = action;
+    return this;
+  }
+};
+var Migrator = class {
+  connection;
+  migrations = [];
+  constructor(connection) {
+    this.connection = connection;
+  }
+  addMigrations(migrations) {
+    this.migrations.push(...migrations);
+  }
+  setMigrations(migrations) {
+    this.migrations = migrations;
+  }
+  async run() {
+    await this.ensureMigrationTable();
+    const ran = await this.getRanMigrations();
+    const ranNames = new Set(ran.map((r) => r.name));
+    const pending = this.migrations.filter((m) => !ranNames.has(m.name));
+    if (pending.length === 0) {
+      console.log("Nothing to migrate.");
+      return;
+    }
+    const nextBatch = await this.getNextBatchNumber();
+    const schema = new SchemaBuilder(this.connection);
+    for (const migration of pending) {
+      console.log(`Migrating: ${migration.name}`);
+      try {
+        await migration.up(schema);
+        await this.recordMigration(migration.name, nextBatch);
+        console.log(`Migrated:  ${migration.name}`);
+      } catch (err) {
+        console.error(`Migration failed: ${migration.name}`, err);
+        throw err;
+      }
+    }
+  }
+  async rollback() {
+    await this.ensureMigrationTable();
+    const lastBatch = await this.getLastBatchNumber();
+    if (lastBatch === 0) {
+      console.log("Nothing to rollback.");
+      return;
+    }
+    const lastBatchMigrations = await this.getMigrationsByBatch(lastBatch);
+    const schema = new SchemaBuilder(this.connection);
+    for (const migration of lastBatchMigrations.reverse()) {
+      const def = this.migrations.find((m) => m.name === migration.name);
+      if (def) {
+        console.log(`Rolling back: ${migration.name}`);
+        try {
+          await def.down(schema);
+          await this.removeMigration(migration.name);
+          console.log(`Rolled back:  ${migration.name}`);
+        } catch (err) {
+          console.error(`Rollback failed: ${migration.name}`, err);
+          throw err;
+        }
+      }
+    }
+  }
+  async reset() {
+    await this.ensureMigrationTable();
+    const allRan = await this.getRanMigrations();
+    const schema = new SchemaBuilder(this.connection);
+    for (const migration of allRan.reverse()) {
+      const def = this.migrations.find((m) => m.name === migration.name);
+      if (def) {
+        console.log(`Resetting: ${migration.name}`);
+        try {
+          await def.down(schema);
+          await this.removeMigration(migration.name);
+          console.log(`Reset:  ${migration.name}`);
+        } catch (err) {
+          console.error(`Reset failed: ${migration.name}`, err);
+          throw err;
+        }
+      }
+    }
+  }
+  async refresh() {
+    await this.reset();
+    await this.run();
+  }
+  async status() {
+    await this.ensureMigrationTable();
+    return this.getRanMigrations();
+  }
+  async ensureMigrationTable() {
+    const dialect = this.connection.getDialect();
+    const sql = dialect.compileCreateMigrationsTable();
+    await this.connection.raw(sql);
+  }
+  async getRanMigrations() {
+    const result = await this.connection.raw(
+      "SELECT name, batch, executed_at as executedAt FROM migrations ORDER BY batch ASC, name ASC"
+    );
+    return result.rows.map((row) => ({
+      name: String(row.name),
+      batch: Number(row.batch),
+      executedAt: String(row.executedAt ?? "")
+    }));
+  }
+  async getNextBatchNumber() {
+    const result = await this.connection.raw(
+      "SELECT COALESCE(MAX(batch), 0) + 1 as next_batch FROM migrations"
+    );
+    return Number(result.rows[0]?.next_batch ?? 1);
+  }
+  async getLastBatchNumber() {
+    const result = await this.connection.raw(
+      "SELECT COALESCE(MAX(batch), 0) as last_batch FROM migrations"
+    );
+    return Number(result.rows[0]?.last_batch ?? 0);
+  }
+  async getMigrationsByBatch(batch) {
+    const result = await this.connection.raw(
+      "SELECT name, batch, executed_at as executedAt FROM migrations WHERE batch = ? ORDER BY name ASC",
+      [batch]
+    );
+    return result.rows.map((row) => ({
+      name: String(row.name),
+      batch: Number(row.batch),
+      executedAt: String(row.executedAt ?? "")
+    }));
+  }
+  async recordMigration(name, batch) {
+    await this.connection.raw(
+      "INSERT INTO migrations (name, batch) VALUES (?, ?)",
+      [name, batch]
+    );
+  }
+  async removeMigration(name) {
+    await this.connection.raw("DELETE FROM migrations WHERE name = ?", [name]);
+  }
+};
+
+// src/server/database/pagination.ts
+var Pagination = class _Pagination {
+  data;
+  currentPage;
+  perPage;
+  total;
+  lastPage;
+  from;
+  to;
+  constructor(result) {
+    this.data = result.data;
+    this.currentPage = result.currentPage;
+    this.perPage = result.perPage;
+    this.total = result.total;
+    this.lastPage = result.lastPage;
+    this.from = result.from;
+    this.to = result.to;
+  }
+  get hasMore() {
+    return this.currentPage < this.lastPage;
+  }
+  get hasPrev() {
+    return this.currentPage > 1;
+  }
+  get isEmpty() {
+    return this.data.length === 0;
+  }
+  nextPage() {
+    if (!this.hasMore) return null;
+    return {
+      page: this.currentPage + 1,
+      perPage: this.perPage,
+      url: null
+    };
+  }
+  prevPage() {
+    if (!this.hasPrev) return null;
+    return {
+      page: this.currentPage - 1,
+      perPage: this.perPage,
+      url: null
+    };
+  }
+  toJSON() {
+    return {
+      data: this.data,
+      pagination: {
+        currentPage: this.currentPage,
+        perPage: this.perPage,
+        total: this.total,
+        lastPage: this.lastPage,
+        from: this.from,
+        to: this.to,
+        hasMore: this.hasMore,
+        hasPrev: this.hasPrev,
+        isEmpty: this.isEmpty
+      }
+    };
+  }
+  map(fn) {
+    return new _Pagination({
+      ...this,
+      data: this.data.map(fn)
+    });
+  }
+  items() {
+    return this.data;
+  }
+  static from(result) {
+    return new _Pagination(result);
+  }
+};
+
+// src/server/database/seeder.ts
+var Seeder = class {
+  connection;
+  constructor(connection) {
+    this.connection = connection;
+  }
+  async call(seederClass) {
+    await seederClass.run(this.connection);
+  }
+  async insert(table, data) {
+    if (data.length === 0) return;
+    const dialect = this.connection.getDialect();
+    const firstRow = data[0];
+    if (!firstRow) return;
+    const columns = Object.keys(firstRow);
+    const wrappedColumns = columns.map((c) => dialect.wrapIdentifier(c)).join(", ");
+    const batchSize = 100;
+    for (let i = 0; i < data.length; i += batchSize) {
+      const batch = data.slice(i, i + batchSize);
+      const placeholders = [];
+      const bindings = [];
+      for (const row of batch) {
+        const rowPlaceholders = columns.map((col) => {
+          bindings.push(row[col]);
+          return dialect.makeParameter(bindings.length - 1);
+        });
+        placeholders.push(`(${rowPlaceholders.join(", ")})`);
+      }
+      const sql = `INSERT INTO ${dialect.wrapIdentifier(table)} (${wrappedColumns}) VALUES ${placeholders.join(", ")}`;
+      await this.connection.raw(sql, bindings);
+    }
+  }
+  async truncate(table) {
+    const dialect = this.connection.getDialect();
+    const driver = this.connection.getDriver();
+    if (driver === "sqlite") {
+      await this.connection.raw(`DELETE FROM ${dialect.wrapIdentifier(table)}`);
+    } else if (driver === "postgresql") {
+      await this.connection.raw(dialect.compileTruncate(table));
+    } else {
+      await this.connection.raw("SET FOREIGN_KEY_CHECKS = 0");
+      await this.connection.raw(dialect.compileTruncate(table));
+      await this.connection.raw("SET FOREIGN_KEY_CHECKS = 1");
+    }
+  }
+  async run() {
+    throw new Error("Seeder.run() must be overridden by subclasses");
+  }
+};
+export {
+  ColumnDefinition,
+  DatabaseConnection,
+  ForeignKeyDefinition,
+  Migrator,
+  MysqlDialect,
+  Pagination,
+  PostgresqlDialect,
+  QueryBuilder,
+  SchemaBuilder,
+  Seeder,
+  SqliteDialect,
+  TableBlueprint,
+  createDialect,
+  createDriver
+};
+//# sourceMappingURL=index.js.map