@ignisia/sql 0.2.1 → 0.3.0

package/dist/cjs/database/alter.d.cts

@@ -0,0 +1,53 @@
+import { D as Database } from '../index-2jl8MRfX.cjs';
+import { Column } from '../column/index.cjs';
+import { AcceptedColumnTypes } from '../column/constants.cjs';
+import { T as Table, D as DatabaseDefinition } from '../index-CnQVnCEI.cjs';
+import { Dialect } from '../table/constants.cjs';
+import 'bun';
+import '../query/constants.cjs';
+import '../column/types.cjs';
+import '../types.cjs';
+
+declare function alterColumnType<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<DatabaseDefinition<DbDialect>>, TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), Type extends Omit<AcceptedColumnTypes, typeof AcceptedColumnTypes.ENUM>, NewTables extends Omit<Tables, TableName> & {
+    [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], ColName> & {
+        [K in ColName]: Tables[TableName]['columns'][ColName] & {
+            type: Type;
+        };
+    }>;
+}>(this: Database<DbDialect, Tables, Definition>, tableName: TableName, columnName: ColName, newType: Type): Promise<Database<DbDialect, Tables, Definition> | Database<DbDialect, NewTables, Definition>>;
+declare function setColumnDefault<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<DatabaseDefinition<DbDialect>>, TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), DefaultValue extends string | number | boolean | null, NewTables extends Omit<Tables, TableName> & {
+    [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], ColName> & {
+        [K in ColName]: Omit<Tables[TableName]['columns'][ColName], 'definition'> & {
+            definition: Omit<Tables[TableName]['columns'][ColName]['definition'], 'default'> & {
+                default: DefaultValue;
+            };
+        };
+    }>;
+}>(this: Database<DbDialect, Tables, Definition>, tableName: TableName, columnName: ColName, value: DefaultValue): Promise<Database<DbDialect, Tables, Definition> | Database<DbDialect, NewTables, Definition>>;
+declare function dropColumnDefault<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<DatabaseDefinition<DbDialect>>, TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewTables extends Omit<Tables, TableName> & {
+    [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], ColName> & {
+        [K in ColName]: Omit<Tables[TableName]['columns'][ColName], 'definition'> & {
+            definition: Omit<Tables[TableName]['columns'][ColName]['definition'], 'default'> & {
+                default: undefined;
+            };
+        };
+    }>;
+}>(this: Database<DbDialect, Tables, Definition>, tableName: TableName, columnName: ColName): Promise<Database<DbDialect, Tables, Definition> | Database<DbDialect, NewTables, Definition>>;
+declare function setColumnNotNull<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<DatabaseDefinition<DbDialect>>, TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewTables extends Omit<Tables, TableName> & {
+    [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], ColName> & {
+        [K in ColName]: Omit<Tables[TableName]['columns'][ColName], 'definition'> & {
+            definition: Omit<Tables[TableName]['columns'][ColName]['definition'], 'notNull'> & {
+                notNull: true;
+            };
+        };
+    }>;
+}>(this: Database<DbDialect, Tables, Definition>, tableName: TableName, columnName: ColName): Promise<Database<DbDialect, Tables, Definition> | Database<DbDialect, NewTables, Definition>>;
+declare function dropColumnNotNull<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<DatabaseDefinition<DbDialect>>, TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewTables extends Omit<Tables, TableName> & {
+    [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], ColName> & {
+        [K in ColName]: Omit<Tables[TableName]['columns'][ColName], 'definition'> & {
+            definition: Omit<Tables[TableName]['columns'][ColName]['definition'], 'notNull'>;
+        };
+    }>;
+}>(this: Database<DbDialect, Tables, Definition>, tableName: TableName, columnName: ColName): Promise<Database<DbDialect, Tables, Definition> | Database<DbDialect, NewTables, Definition>>;
+
+export { alterColumnType, dropColumnDefault, dropColumnNotNull, setColumnDefault, setColumnNotNull };

package/dist/cjs/database/alter.js

@@ -0,0 +1,93 @@
+'use strict';
+
+var constants = require('../table/constants');
+
+async function alterColumnType(tableName, columnName, newType) {
+  if (this.dialect === constants.Dialect.SQLITE) {
+    throw new Error("SQLite does not support ALTER COLUMN TYPE directly.");
+  }
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} TYPE ${newType}`
+  });
+  if (!this.tables[tableName]) return this;
+  this.tables[tableName].columns[columnName].type = newType;
+  return this;
+}
+async function setColumnDefault(tableName, columnName, value) {
+  if (this.dialect === constants.Dialect.SQLITE) {
+    throw new Error("SQLite does not support ALTER COLUMN DEFAULT directly.");
+  }
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET DEFAULT ${value}`
+  });
+  if (!this.tables[tableName]) return this;
+  if (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    !this.tables[tableName].columns[columnName].definition
+  ) {
+    this.tables[tableName].columns[columnName].definition = {};
+  }
+  this.tables[tableName].columns[columnName].definition.default = value;
+  return this;
+}
+async function dropColumnDefault(tableName, columnName) {
+  if (this.dialect === constants.Dialect.SQLITE) {
+    throw new Error("SQLite does not support DROP DEFAULT directly.");
+  }
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP DEFAULT`
+  });
+  if (!this.tables[tableName]) return this;
+  if (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    !this.tables[tableName].columns[columnName].definition
+  ) {
+    this.tables[tableName].columns[columnName].definition = {};
+  }
+  delete this.tables[tableName].columns[columnName].definition.default;
+  return this;
+}
+async function setColumnNotNull(tableName, columnName) {
+  if (this.dialect === constants.Dialect.SQLITE) {
+    throw new Error(
+      "SQLite does not support SET NOT NULL (requires table rebuild)"
+    );
+  }
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET NOT NULL`
+  });
+  if (!this.tables[tableName]) return this;
+  if (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    !this.tables[tableName].columns[columnName].definition
+  ) {
+    this.tables[tableName].columns[columnName].definition = {};
+  }
+  this.tables[tableName].columns[columnName].definition.notNull = true;
+  return this;
+}
+async function dropColumnNotNull(tableName, columnName) {
+  if (this.dialect === constants.Dialect.SQLITE) {
+    throw new Error(
+      "SQLite does not support DROP NOT NULL (requires table rebuild)"
+    );
+  }
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP NOT NULL`
+  });
+  if (!this.tables[tableName]) return this;
+  if (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    !this.tables[tableName].columns[columnName].definition
+  ) {
+    this.tables[tableName].columns[columnName].definition = {};
+  }
+  this.tables[tableName].columns[columnName].definition.notNull = null;
+  return this;
+}
+
+exports.alterColumnType = alterColumnType;
+exports.dropColumnDefault = dropColumnDefault;
+exports.dropColumnNotNull = dropColumnNotNull;
+exports.setColumnDefault = setColumnDefault;
+exports.setColumnNotNull = setColumnNotNull;

package/dist/cjs/database/column.d.cts

@@ -0,0 +1,25 @@
+import { D as Database } from '../index-2jl8MRfX.cjs';
+import { Column } from '../column/index.cjs';
+import { T as Table, D as DatabaseDefinition } from '../index-CnQVnCEI.cjs';
+import { Dialect } from '../table/constants.cjs';
+import 'bun';
+import '../query/constants.cjs';
+import '../column/constants.cjs';
+import '../column/types.cjs';
+import '../types.cjs';
+
+declare function addColumn<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<DatabaseDefinition<DbDialect>>, TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewTables extends Omit<Tables, TableName> & {
+    [K in TableName]: Table<TableName, Tables[TableName]['columns'] & {
+        [K in ColName]: Column;
+    }>;
+}>(this: Database<DbDialect, Tables, Definition>, tableName: TableName, columnName: ColName, column: Column): Promise<Database<DbDialect, Tables, Definition> | Database<DbDialect, NewTables, Definition>>;
+declare function renameColumn<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<DatabaseDefinition<DbDialect>>, TableName extends (keyof Tables & string) | (string & {}), OldName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewTables extends Omit<Tables, TableName> & {
+    [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], OldName> & {
+        [K in NewName]: Tables[TableName]['columns'][OldName];
+    }>;
+}>(this: Database<DbDialect, Tables, Definition>, tableName: TableName, oldName: OldName, newName: NewName): Promise<Database<DbDialect, Tables, Definition> | Database<DbDialect, NewTables, Definition>>;
+declare function dropColumn<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<DatabaseDefinition<DbDialect>>, TableName extends (keyof Tables & string) | (string & {}), ColName extends (keyof Tables[TableName]['columns'] & string) | (string & {}), NewTables extends Omit<Tables, TableName> & {
+    [K in TableName]: Table<TableName, Omit<Tables[TableName]['columns'], ColName>>;
+}>(this: Database<DbDialect, Tables, Definition>, tableName: TableName, columnName: ColName): Promise<Database<DbDialect, Tables, Definition> | Database<DbDialect, NewTables, Definition>>;
+
+export { addColumn, dropColumn, renameColumn };

package/dist/cjs/database/column.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var constants = require('../table/constants');
+
+async function addColumn(tableName, columnName, column) {
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${column.toString()};`
+  });
+  if (!this.tables[tableName]) return this;
+  this.tables[tableName].columns[columnName] = column;
+  return this;
+}
+async function renameColumn(tableName, oldName, newName) {
+  if (this.dialect === constants.Dialect.SQLITE) {
+    throw new Error("SQLite does not support RENAME COLUMN natively.");
+  }
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} RENAME COLUMN ${oldName} TO ${newName};`
+  });
+  if (!this.tables[tableName]) return this;
+  this.tables[tableName].columns[newName] = this.tables[tableName].columns[oldName];
+  delete this.tables[tableName].columns[oldName];
+  return this;
+}
+async function dropColumn(tableName, columnName) {
+  if (this.dialect === constants.Dialect.SQLITE) {
+    throw new Error("SQLite does not support DROP COLUMN natively.");
+  }
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} DROP COLUMN ${columnName};`
+  });
+  if (!this.tables[tableName]) return this;
+  delete this.tables[tableName].columns[columnName];
+  return this;
+}
+
+exports.addColumn = addColumn;
+exports.dropColumn = dropColumn;
+exports.renameColumn = renameColumn;

package/dist/cjs/database/contract.d.cts

@@ -0,0 +1,9 @@
+export { C as ColumnAlterationContract, T as TableAlterationContract } from '../index-2jl8MRfX.cjs';
+import '../column/index.cjs';
+import '../column/constants.cjs';
+import '../index-CnQVnCEI.cjs';
+import '../table/constants.cjs';
+import 'bun';
+import '../query/constants.cjs';
+import '../column/types.cjs';
+import '../types.cjs';

package/dist/cjs/database/contract.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/cjs/database/index.d.cts

@@ -0,0 +1,9 @@
+import 'bun';
+import '../column/index.cjs';
+import '../index-CnQVnCEI.cjs';
+import '../query/constants.cjs';
+import '../table/constants.cjs';
+export { D as Database } from '../index-2jl8MRfX.cjs';
+import '../column/constants.cjs';
+import '../column/types.cjs';
+import '../types.cjs';

package/dist/cjs/database/index.js

@@ -0,0 +1,107 @@
+'use strict';
+
+require('../table');
+var constants = require('../table/constants');
+var alter = require('./alter');
+var column = require('./column');
+var table = require('./table');
+var wrapper = require('./wrapper');
+
+class Database {
+  hooks;
+  dialect;
+  defintion;
+  tables;
+  client;
+  createTable;
+  renameTable;
+  dropTable;
+  addColumn;
+  renameColumn;
+  dropColumn;
+  alterColumnType;
+  setColumnDefault;
+  dropColumnDefault;
+  setColumnNotNull;
+  dropColumnNotNull;
+  constructor(options) {
+    this.hooks = {};
+    this.dialect = options.dialect;
+    this.tables = options.tables ?? {};
+    this.defintion = {
+      dialect: options.dialect,
+      config: options.config
+    };
+    this.client = this.createClient(options);
+    if (options.tables) {
+      for (const tableName in options.tables) {
+        options.tables[tableName].client = this.client;
+        options.tables[tableName].setDialect(this.dialect);
+      }
+    }
+    this.createTable = table.createTable.bind(this);
+    this.renameTable = table.renameTable.bind(this);
+    this.dropTable = table.dropTable.bind(this);
+    this.addColumn = column.addColumn.bind(this);
+    this.renameColumn = column.renameColumn.bind(this);
+    this.dropColumn = column.dropColumn.bind(this);
+    this.alterColumnType = alter.alterColumnType.bind(
+      this
+    );
+    this.setColumnDefault = alter.setColumnDefault.bind(
+      this
+    );
+    this.dropColumnDefault = alter.dropColumnDefault.bind(
+      this
+    );
+    this.setColumnNotNull = alter.setColumnDefault.bind(
+      this
+    );
+    this.dropColumnNotNull = alter.dropColumnNotNull.bind(
+      this
+    );
+  }
+  createClient(options) {
+    switch (options.dialect) {
+      case constants.Dialect.SQLITE:
+        return new wrapper.DatabaseSqlite(options.config);
+      case constants.Dialect.POSTGRES:
+        return new wrapper.DatabasePsql(options.config);
+      case constants.Dialect.MYSQL:
+        return new wrapper.DatabaseMysql(options.config);
+      default:
+        throw new Error(`Dialect ${options.dialect} is not supported`);
+    }
+  }
+  table(tableName) {
+    if (!this.tables[tableName]) {
+      throw new Error(`Table ${tableName} does not exist`);
+    }
+    const table = this.tables[tableName];
+    const query = table.query();
+    query.hooks.before = this.hooks.before;
+    query.hooks.after = this.hooks.after;
+    return query;
+  }
+  addHook(type, fn) {
+    if (!this.hooks[type]) {
+      this.hooks[type] = /* @__PURE__ */ new Set();
+    }
+    this.hooks[type].add(fn);
+    return this;
+  }
+  removeHook(type, fn) {
+    if (this.hooks[type]) {
+      this.hooks[type].delete(fn);
+    }
+    return this;
+  }
+  async transaction(fn) {
+    return this.client.transaction(fn);
+  }
+  static define(options) {
+    return new Database(options);
+  }
+}
+
+exports.Database = Database;

package/dist/cjs/database/table.d.cts

@@ -0,0 +1,22 @@
+import { D as Database } from '../index-2jl8MRfX.cjs';
+import { Column } from '../column/index.cjs';
+import { T as Table, D as DatabaseDefinition, a as TimestampOptions, M as MergeTimestampParanoid } from '../index-CnQVnCEI.cjs';
+import { Dialect } from '../table/constants.cjs';
+import 'bun';
+import '../query/constants.cjs';
+import '../column/constants.cjs';
+import '../column/types.cjs';
+import '../types.cjs';
+
+declare function createTable<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<DatabaseDefinition<DbDialect>>, TableName extends string, Columns extends Record<string, Column>, CreatedAt extends string, UpdatedAt extends string, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean, FinalColumns extends MergeTimestampParanoid<Columns, CreatedAt, UpdatedAt, Timestamp, Paranoid>, NewTables extends Tables & {
+    [K in TableName]: Table<TableName, FinalColumns, DbDialect, CreatedAt, UpdatedAt, Timestamp, Paranoid>;
+}>(this: Database<DbDialect, Tables, Definition>, tableName: TableName, columns: Columns, options?: {
+    paranoid?: Paranoid;
+    timestamp?: Timestamp;
+}): Promise<Database<DbDialect, NewTables, Definition>>;
+declare function renameTable<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<DatabaseDefinition<DbDialect>>, OldName extends (keyof Tables & string) | (string & {}), NewName extends string, NewTables extends Omit<Tables, OldName> & {
+    [K in NewName]: Tables[OldName];
+}>(this: Database<DbDialect, Tables, Definition>, oldName: OldName, newName: NewName): Promise<Database<DbDialect, NewTables, Definition>>;
+declare function dropTable<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<DatabaseDefinition<DbDialect>>, TableName extends (keyof Tables & string) | (string & {})>(this: Database<DbDialect, Tables, Definition>, tableName: TableName): Promise<Database<DbDialect, Omit<Tables, TableName>, Definition>>;
+
+export { createTable, dropTable, renameTable };

package/dist/cjs/database/table.js

@@ -0,0 +1,49 @@
+'use strict';
+
+var table = require('../table');
+
+async function createTable(tableName, columns, options) {
+  const table$1 = table.Table.define({
+    name: tableName,
+    dialect: this.dialect,
+    columns,
+    ...options
+  });
+  table$1.client = this.client;
+  this.tables[tableName] = table$1;
+  if (!this?.client) {
+    throw new Error("Database not connected");
+  }
+  while (this.client.status === "connecting") {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  await table$1.create({
+    db: this.client
+  });
+  return this;
+}
+async function renameTable(oldName, newName) {
+  await this.client.exec({
+    sql: `ALTER TABLE ${oldName} RENAME TO ${newName};`
+  });
+  this.tables[newName] = this.tables[oldName];
+  delete this.tables[oldName];
+  return this;
+}
+async function dropTable(tableName) {
+  if (!this.tables[tableName]) {
+    await this.client.exec({
+      sql: `DROP TABLE IF EXISTS ${tableName};`
+    });
+    return this;
+  }
+  await this.tables[tableName].drop({
+    db: this.client
+  });
+  delete this.tables[tableName];
+  return this;
+}
+
+exports.createTable = createTable;
+exports.dropTable = dropTable;
+exports.renameTable = renameTable;

package/dist/cjs/database/types.d.cts

@@ -0,0 +1,8 @@
+import 'bun';
+import '../column/index.cjs';
+export { D as DatabaseDefinition, b as DatabaseDialect, c as DatabaseExecOptions, i as DatabaseOptions, s as MysqlConfig, P as PostgresConfig, r as SqlConfig, S as SqlConfigMapping, d as SqliteConfig } from '../index-CnQVnCEI.cjs';
+import '../table/constants.cjs';
+import '../column/constants.cjs';
+import '../column/types.cjs';
+import '../types.cjs';
+import '../query/constants.cjs';

package/dist/cjs/database/types.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/cjs/database/wrapper.d.cts

@@ -0,0 +1,32 @@
+import { SQL, TransactionSQL } from 'bun';
+import { Dialect } from '../table/constants.cjs';
+import { S as SqlConfigMapping, b as DatabaseDialect, c as DatabaseExecOptions, P as PostgresConfig, d as SqliteConfig } from '../index-CnQVnCEI.cjs';
+import '../column/index.cjs';
+import '../column/constants.cjs';
+import '../column/types.cjs';
+import '../types.cjs';
+import '../query/constants.cjs';
+
+declare class BaseSql<DbDialect extends Dialect, Options extends SqlConfigMapping[DbDialect]> implements DatabaseDialect {
+    readonly dialect: Dialect;
+    readonly options: Options;
+    client: SQL;
+    status: 'connecting' | 'connected' | 'disconnected';
+    constructor(dialect: Dialect, options: Options);
+    connect(): Promise<this>;
+    disconnect(): Promise<this>;
+    exec<T>(options: DatabaseExecOptions): Promise<T>;
+    transaction<T, U extends (tx: TransactionSQL) => Promise<T>>(fn: U): Promise<T>;
+    distributed<T extends string, U, V extends (tx: TransactionSQL) => Promise<U>>(name: T, fn: V): Promise<U>;
+}
+declare class DatabasePsql extends BaseSql<typeof Dialect.POSTGRES, PostgresConfig> {
+    constructor(options: PostgresConfig);
+}
+declare class DatabaseMysql extends BaseSql<typeof Dialect.MYSQL, PostgresConfig> {
+    constructor(options: PostgresConfig);
+}
+declare class DatabaseSqlite extends BaseSql<typeof Dialect.SQLITE, SqliteConfig> {
+    constructor(options: SqliteConfig);
+}
+
+export { BaseSql, DatabaseMysql, DatabasePsql, DatabaseSqlite };

package/dist/cjs/database/wrapper.js

@@ -0,0 +1,87 @@
+'use strict';
+
+var bun = require('bun');
+var constants = require('../table/constants');
+
+class BaseSql {
+  dialect;
+  options;
+  client;
+  status;
+  constructor(dialect, options) {
+    this.dialect = dialect;
+    this.options = options;
+    this.status = "connecting";
+    this.client = new bun.SQL({
+      ...options,
+      adapter: dialect,
+      onconnect: () => {
+        this.status = "connected";
+      },
+      onclose: () => {
+        this.status = "disconnected";
+      }
+    });
+    this.connect();
+  }
+  async connect() {
+    await this.client.connect();
+    return this;
+  }
+  async disconnect() {
+    await this.client.close();
+    return this;
+  }
+  async exec(options) {
+    const client = options.tx || this.client;
+    if (!client) {
+      throw new Error("Database not connected");
+    }
+    if (!options.params) {
+      return client.unsafe(options.sql);
+    }
+    const params = (options.params ?? []).map((param) => {
+      if (param === null || typeof param === "string" || typeof param === "number" || typeof param === "boolean" || typeof param === "bigint") {
+        return param;
+      }
+      if (param === void 0) {
+        return null;
+      }
+      if (param instanceof Date) {
+        return param.toISOString();
+      }
+      try {
+        return JSON.stringify(param);
+      } catch {
+        return null;
+      }
+    });
+    return client.unsafe(options.sql, params);
+  }
+  async transaction(fn) {
+    return this.client.transaction(fn);
+  }
+  async distributed(name, fn) {
+    return this.client.distributed(name, fn);
+  }
+}
+class DatabasePsql extends BaseSql {
+  constructor(options) {
+    super(constants.Dialect.POSTGRES, options);
+  }
+}
+class DatabaseMysql extends BaseSql {
+  constructor(options) {
+    super(constants.Dialect.MYSQL, options);
+  }
+}
+class DatabaseSqlite extends BaseSql {
+  constructor(options) {
+    super(constants.Dialect.SQLITE, options);
+  }
+}
+
+exports.BaseSql = BaseSql;
+exports.DatabaseMysql = DatabaseMysql;
+exports.DatabasePsql = DatabasePsql;
+exports.DatabaseSqlite = DatabaseSqlite;