@ignisia/sql 0.2.1 → 0.3.0

package/dist/{database → esm/database}/column.js

@@ -1,9 +1,10 @@
-import { Dialect } from '../table/constants';
+import { Dialect } from '../table/constants.js';
 
+// src/database/column.ts
 async function addColumn(tableName, columnName, column) {
-  await this.client.exec(
-    `ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${column.toString()};`
-  );
+  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;
@@ -12,9 +13,9 @@ async function renameColumn(tableName, oldName, newName) {
   if (this.dialect === Dialect.SQLITE) {
     throw new Error("SQLite does not support RENAME COLUMN natively.");
   }
-  await this.client.exec(
-    `ALTER TABLE ${tableName} RENAME COLUMN ${oldName} TO ${newName};`
-  );
+  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];
@@ -24,7 +25,9 @@ async function dropColumn(tableName, columnName) {
   if (this.dialect === Dialect.SQLITE) {
     throw new Error("SQLite does not support DROP COLUMN natively.");
   }
-  await this.client.exec(`ALTER TABLE ${tableName} DROP COLUMN ${columnName};`);
+  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;

package/dist/{database → esm/database}/contract.d.ts

@@ -1,8 +1,9 @@
-export { C as ColumnAlterationContract, T as TableAlterationContract } from '../index-DFrpzXEn.js';
+export { C as ColumnAlterationContract, T as TableAlterationContract } from '../index-BXOAxB_h.js';
 import '../column/index.js';
 import '../column/constants.js';
-import '../index-FMT0YEO7.js';
+import '../index-BdpoD4zk.js';
 import '../table/constants.js';
+import 'bun';
 import '../query/constants.js';
 import '../column/types.js';
 import '../types.js';

package/dist/{database → esm/database}/index.d.ts

@@ -1,8 +1,9 @@
+import 'bun';
 import '../column/index.js';
-import '../index-FMT0YEO7.js';
+import '../index-BdpoD4zk.js';
 import '../query/constants.js';
 import '../table/constants.js';
-export { D as Database } from '../index-DFrpzXEn.js';
+export { D as Database } from '../index-BXOAxB_h.js';
 import '../column/constants.js';
 import '../column/types.js';
 import '../types.js';

package/dist/{database → esm/database}/index.js

@@ -1,11 +1,12 @@
-import '../table';
-import { Dialect } from '../table/constants';
-import { alterColumnType, setColumnDefault, dropColumnDefault, dropColumnNotNull } from './alter';
-import { addColumn, renameColumn, dropColumn } from './column';
-import { createTable, renameTable, dropTable } from './table';
-import { DatabasePsql, DatabaseSqlite } from './wrapper';
+import '../table/index.js';
+import { Dialect } from '../table/constants.js';
+import { alterColumnType, setColumnDefault, dropColumnDefault, dropColumnNotNull } from './alter.js';
+import { addColumn, renameColumn, dropColumn } from './column.js';
+import { createTable, renameTable, dropTable } from './table.js';
+import { DatabaseMysql, DatabasePsql, DatabaseSqlite } from './wrapper.js';
 
-class Database {
+// src/database/index.ts
+var Database = class _Database {
   hooks;
   dialect;
   defintion;
@@ -30,10 +31,11 @@ class Database {
       dialect: options.dialect,
       config: options.config
     };
-    this.client = options.dialect === Dialect.POSTGRES ? new DatabasePsql(options.config) : new DatabaseSqlite(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 = createTable.bind(this);
@@ -58,6 +60,18 @@ class Database {
       this
     );
   }
+  createClient(options) {
+    switch (options.dialect) {
+      case Dialect.SQLITE:
+        return new DatabaseSqlite(options.config);
+      case Dialect.POSTGRES:
+        return new DatabasePsql(options.config);
+      case Dialect.MYSQL:
+        return new 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`);
@@ -85,8 +99,8 @@ class Database {
     return this.client.transaction(fn);
   }
   static define(options) {
-    return new Database(options);
+    return new _Database(options);
   }
-}
+};
 
 export { Database };

package/dist/{database → esm/database}/table.d.ts

@@ -1,7 +1,8 @@
-import { D as Database } from '../index-DFrpzXEn.js';
+import { D as Database } from '../index-BXOAxB_h.js';
 import { Column } from '../column/index.js';
-import { T as Table, D as DatabaseDefinition, a as TimestampOptions, M as MergeTimestampParanoid } from '../index-FMT0YEO7.js';
+import { T as Table, D as DatabaseDefinition, a as TimestampOptions, M as MergeTimestampParanoid } from '../index-BdpoD4zk.js';
 import { Dialect } from '../table/constants.js';
+import 'bun';
 import '../query/constants.js';
 import '../column/constants.js';
 import '../column/types.js';

package/dist/{database → esm/database}/table.js

@@ -1,5 +1,6 @@
-import { Table } from '../table';
+import { Table } from '../table/index.js';
 
+// src/database/table.ts
 async function createTable(tableName, columns, options) {
   const table = Table.define({
     name: tableName,
@@ -15,21 +16,29 @@ async function createTable(tableName, columns, options) {
   while (this.client.status === "connecting") {
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
-  await table.create(this.client);
+  await table.create({
+    db: this.client
+  });
   return this;
 }
 async function renameTable(oldName, newName) {
-  await this.client.exec(`ALTER TABLE ${oldName} RENAME TO ${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(`DROP TABLE IF EXISTS ${tableName};`);
+    await this.client.exec({
+      sql: `DROP TABLE IF EXISTS ${tableName};`
+    });
     return this;
   }
-  await this.tables[tableName].drop(this.client);
+  await this.tables[tableName].drop({
+    db: this.client
+  });
   delete this.tables[tableName];
   return this;
 }

package/dist/esm/database/types.d.ts

@@ -0,0 +1,8 @@
+import 'bun';
+import '../column/index.js';
+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-BdpoD4zk.js';
+import '../table/constants.js';
+import '../column/constants.js';
+import '../column/types.js';
+import '../types.js';
+import '../query/constants.js';

package/dist/esm/database/wrapper.d.ts

@@ -0,0 +1,32 @@
+import { SQL, TransactionSQL } from 'bun';
+import { Dialect } from '../table/constants.js';
+import { S as SqlConfigMapping, b as DatabaseDialect, c as DatabaseExecOptions, P as PostgresConfig, d as SqliteConfig } from '../index-BdpoD4zk.js';
+import '../column/index.js';
+import '../column/constants.js';
+import '../column/types.js';
+import '../types.js';
+import '../query/constants.js';
+
+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/esm/database/wrapper.js

@@ -0,0 +1,83 @@
+import { SQL } from 'bun';
+import { Dialect } from '../table/constants.js';
+
+// src/database/wrapper.ts
+var BaseSql = class {
+  dialect;
+  options;
+  client;
+  status;
+  constructor(dialect, options) {
+    this.dialect = dialect;
+    this.options = options;
+    this.status = "connecting";
+    this.client = new 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);
+  }
+};
+var DatabasePsql = class extends BaseSql {
+  constructor(options) {
+    super(Dialect.POSTGRES, options);
+  }
+};
+var DatabaseMysql = class extends BaseSql {
+  constructor(options) {
+    super(Dialect.MYSQL, options);
+  }
+};
+var DatabaseSqlite = class extends BaseSql {
+  constructor(options) {
+    super(Dialect.SQLITE, options);
+  }
+};
+
+export { BaseSql, DatabaseMysql, DatabasePsql, DatabaseSqlite };

package/dist/{index-DFrpzXEn.d.ts → esm/index-BXOAxB_h.d.ts}

@@ -1,5 +1,6 @@
+import { TransactionSQL } from 'bun';
 import { Column } from './column/index.js';
-import { T as Table, D as DatabaseDefinition, a as TimestampOptions, M as MergeTimestampParanoid, f as QuerHooks, b as DatabaseDialect, g as DatabaseOptions, d as QueryBuilder, h as QueryRunHooks } from './index-FMT0YEO7.js';
+import { T as Table, D as DatabaseDefinition, a as TimestampOptions, M as MergeTimestampParanoid, h as QuerHooks, b as DatabaseDialect, i as DatabaseOptions, f as QueryBuilder, j as QueryRunHooks } from './index-BdpoD4zk.js';
 import { QueryHooksType } from './query/constants.js';
 import { Dialect } from './table/constants.js';
 import { AcceptedColumnTypes } from './column/constants.js';
@@ -93,10 +94,11 @@ declare class Database<DbDialect extends Dialect, Tables extends Record<string,
     setColumnNotNull: ColumnAlterationContract<DbDialect, Tables, Definition>['setColumnNotNull'];
     dropColumnNotNull: ColumnAlterationContract<DbDialect, Tables, Definition>['dropColumnNotNull'];
     protected constructor(options: DatabaseOptions<DbDialect, Tables>);
+    private createClient;
     table<TableName extends keyof Tables & string, Table extends Tables[TableName]>(tableName: TableName): QueryBuilder<TableName, Table>;
     addHook(type: QueryHooksType, fn: QueryRunHooks): this;
     removeHook(type: QueryHooksType, fn: QueryRunHooks): this;
-    transaction<T, U extends () => Promise<T>>(fn: U): Promise<unknown>;
+    transaction<T, U extends (tx: TransactionSQL) => Promise<T>>(fn: U): Promise<unknown>;
     static define<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>>(options: DatabaseOptions<DbDialect, Tables>): Database<DbDialect, Tables, DatabaseDefinition<DbDialect>>;
 }
 

package/dist/{index-FMT0YEO7.d.ts → esm/index-BdpoD4zk.d.ts}

@@ -2,6 +2,7 @@ import { Column } from './column/index.js';
 import { AcceptedColumnTypes } from './column/constants.js';
 import { UnionToIntersection } from './types.js';
 import { QueryType, OrderBy, AggregationFunction, QueryHooksType, AcceptedOperator, ConditionClause, LogicalOperator } from './query/constants.js';
+import { TransactionSQL } from 'bun';
 import { Dialect } from './table/constants.js';
 
 type ColumnSelector<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>> = `${Alias}."${keyof TableRef['columns'] & string}"` | `${Alias}.*` | {
@@ -132,6 +133,52 @@ interface QuerHooks {
     before: Set<QueryRunHooks>;
 }
 
+type SqlConfigMapping = {
+    [Dialect.POSTGRES]: PostgresConfig;
+    [Dialect.MYSQL]: MysqlConfig;
+    [Dialect.SQLITE]: SqliteConfig;
+};
+interface SqliteConfig {
+    filename: ':memory:' | (string & {});
+}
+interface SqlConfig {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database: string;
+}
+interface PostgresConfig extends SqlConfig {
+}
+interface MysqlConfig extends SqlConfig {
+}
+interface DatabaseOptions<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>> {
+    dialect: DbDialect;
+    config: SqlConfigMapping[DbDialect];
+    tables?: Tables;
+}
+interface DatabaseExecOptions {
+    sql: string;
+    params?: unknown[] | null | undefined;
+    tx?: TransactionSQL | null;
+}
+interface DatabaseDefinition<DbDialect extends Dialect> extends Omit<DatabaseOptions<DbDialect, any>, 'tables'> {
+}
+interface DatabaseDialect {
+    status: 'connecting' | 'connected' | 'disconnected';
+    connect(): Promise<this>;
+    disconnect(): Promise<this>;
+    exec<T>(options: DatabaseExecOptions): Promise<T>;
+    /**
+     * Begins a transaction
+     */
+    transaction<T, U extends (tx: TransactionSQL) => Promise<T>>(fn: U): Promise<T>;
+    /**
+     * Begins a distributed transaction
+     */
+    distributed<T extends string, U, V extends (tx: TransactionSQL) => Promise<U>>(name: T, fn: V): Promise<U>;
+}
+
 declare const createdAt: Column<AcceptedColumnTypes, number | readonly string[], {
     type: "DATETIME";
 }, Date, Date, {
@@ -143,68 +190,50 @@ declare const updatedAt: Column<AcceptedColumnTypes, number | readonly string[],
 declare const deletedAt: Column<AcceptedColumnTypes, number | readonly string[], {
     type: "DATETIME";
 }, Date, Date, {}>;
-declare function defineColumns<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>>(options: TableOptions<TableName, Columns, Dialect, CreatedAt, UpdatedAt, Timestamp, Paranoid>): FinalColumns;
+declare function defineColumns<TableName extends string, Columns extends Record<string, Column>, CreatedAt extends string | boolean, UpdatedAt extends string | boolean, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean, FinalColumns extends MergeTimestampParanoid<Columns, CreatedAt, UpdatedAt, Timestamp, Paranoid>>(options: TableOptions<TableName, Columns, Dialect, CreatedAt, UpdatedAt, Timestamp, Paranoid>): FinalColumns;
 
-interface TimestampOptions<CreatedAt extends string, UpdatedAt extends string> {
+interface TimestampOptions<CreatedAt extends string | boolean, UpdatedAt extends string | boolean> {
     createdAt?: CreatedAt;
     updatedAt?: UpdatedAt;
 }
-interface TableOptions<TableName extends string, Columns extends Record<string, Column>, DbDialect extends Dialect, CreatedAt extends string, UpdatedAt extends string, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean> {
-    dialect: DbDialect;
+interface TableOptions<TableName extends string, Columns extends Record<string, Column>, DbDialect extends Dialect, CreatedAt extends string | boolean, UpdatedAt extends string | boolean, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean> {
+    dialect?: DbDialect;
     name: TableName;
     columns: Columns;
     paranoid?: Paranoid;
     timestamp?: Timestamp;
 }
-type MergeTimestampParanoid<Columns extends Record<string, Column>, CreatedAt extends string, UpdatedAt extends string, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean> = Columns & (Timestamp extends true ? {
+type MergeTimestampParanoid<Columns extends Record<string, Column>, CreatedAt extends string | boolean, UpdatedAt extends string | boolean, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean> = Columns & (Timestamp extends true ? {
     createdAt: typeof createdAt;
     updatedAt: typeof updatedAt;
-} : Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> ? (Timestamp['createdAt'] extends CreatedAt ? {
+} : Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> ? (Timestamp['createdAt'] extends CreatedAt ? Timestamp['createdAt'] extends true ? {
+    createdAt: typeof createdAt;
+} : Timestamp['createdAt'] extends string ? {
     [K in Timestamp['createdAt']]: typeof createdAt;
-} : {
+} : NonNullable<unknown> : {
     createdAt: typeof createdAt;
-}) & (Timestamp['updatedAt'] extends UpdatedAt ? {
+}) & (Timestamp['updatedAt'] extends UpdatedAt ? Timestamp['updatedAt'] extends true ? {
+    updatedAt: typeof updatedAt;
+} : Timestamp['updatedAt'] extends string ? {
     [K in Timestamp['updatedAt']]: typeof updatedAt;
-} : {
+} : NonNullable<unknown> : {
     updatedAt: typeof updatedAt;
 }) : NonNullable<unknown>) & (Paranoid extends true ? {
     deletedAt: typeof deletedAt;
 } : Paranoid extends string ? {
     [K in Paranoid]: typeof deletedAt;
 } : NonNullable<unknown>);
-type TableOutput<TableName extends string, Columns extends Record<string, Column>, DbDialect extends Dialect, CreatedAt extends string, UpdatedAt extends string, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean, TableRef extends Table<TableName, Columns, DbDialect, CreatedAt, UpdatedAt, Timestamp, Paranoid> = Table<TableName, Columns, DbDialect, CreatedAt, UpdatedAt, Timestamp, Paranoid>> = {
+type TableOutput<TableName extends string, Columns extends Record<string, Column>, DbDialect extends Dialect, CreatedAt extends string | boolean, UpdatedAt extends string | boolean, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean, TableRef extends Table<TableName, Columns, DbDialect, CreatedAt, UpdatedAt, Timestamp, Paranoid> = Table<TableName, Columns, DbDialect, CreatedAt, UpdatedAt, Timestamp, Paranoid>> = {
     [K in keyof TableRef['columns'] & string]: TableRef['columns'][K]['_output'];
 };
-
-interface SqliteConfig {
-    filename: string;
-}
-interface PostgresConfig {
-    host: string;
-    port: number;
-    user: string;
-    password: string;
-    database: string;
-}
-interface DatabaseOptions<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>> {
-    dialect: DbDialect;
-    config: DbDialect extends typeof Dialect.POSTGRES ? PostgresConfig : SqliteConfig;
-    tables?: Tables;
-}
-interface DatabaseDefinition<DbDialect extends Dialect> extends Omit<DatabaseOptions<DbDialect, any>, 'tables'> {
-}
-interface DatabaseDialect {
-    status: 'connecting' | 'connected' | 'disconnected';
-    connect(): Promise<this>;
-    disconnect(): Promise<this>;
-    exec<T>(sql: string): Promise<T>;
-    exec<T>(sql: string, params: any): Promise<T>;
-    transaction<T, U extends () => Promise<T>>(fn: U): Promise<T>;
+interface ExecOptions {
+    tx?: TransactionSQL | null;
+    db?: DatabaseDialect | null;
 }
 
-declare class Table<TableName extends string, Columns extends Record<string, Column>, DbDialect extends Dialect = Dialect, CreatedAt extends string = string, UpdatedAt extends string = string, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean = TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean = string | boolean> {
+declare class Table<TableName extends string, Columns extends Record<string, Column>, DbDialect extends Dialect = Dialect, CreatedAt extends string | boolean = string | boolean, UpdatedAt extends string | boolean = string | boolean, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean = TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean = string | boolean> {
     client: DatabaseDialect | null;
-    readonly dialect: DbDialect;
+    private _dialect;
     readonly name: TableName;
     readonly columns: Columns;
     readonly timestamp: Timestamp | null;
@@ -212,16 +241,19 @@ declare class Table<TableName extends string, Columns extends Record<string, Col
     readonly _output: TableOutput<TableName, Columns, DbDialect, CreatedAt, UpdatedAt, Timestamp, Paranoid>;
     protected constructor(options: TableOptions<TableName, Columns, DbDialect, CreatedAt, UpdatedAt, Timestamp, Paranoid>);
     infer(): this['_output'];
-    static define<TableName extends string, Columns extends Record<string, Column>, DbDialect extends Dialect, CreatedAt extends string, UpdatedAt extends string, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean>(options: TableOptions<TableName, Columns, DbDialect, CreatedAt, UpdatedAt, Timestamp, Paranoid>): Table<TableName, MergeTimestampParanoid<Columns, CreatedAt, UpdatedAt, Timestamp, Paranoid>, DbDialect, string, string, Timestamp, Paranoid>;
-    create(db?: DatabaseDialect | null): Promise<this>;
-    drop(db?: DatabaseDialect | null): Promise<this>;
+    static define<TableName extends string, Columns extends Record<string, Column>, DbDialect extends Dialect, CreatedAt extends string | boolean, UpdatedAt extends string | boolean, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean>(options: TableOptions<TableName, Columns, DbDialect, CreatedAt, UpdatedAt, Timestamp, Paranoid>): Table<TableName, MergeTimestampParanoid<Columns, CreatedAt, UpdatedAt, Timestamp, Paranoid>, DbDialect, string | boolean, string | boolean, Timestamp, Paranoid>;
+    setColumnDialect<DbDialect extends Dialect>(dialect: DbDialect): void;
+    get dialect(): DbDialect | null;
+    setDialect<DbDialect extends Dialect>(dialect: DbDialect): Table<TableName, Columns, DbDialect, CreatedAt, UpdatedAt, Timestamp, Paranoid>;
+    create(options?: ExecOptions): Promise<this>;
+    drop(options?: ExecOptions): Promise<this>;
     query(): QueryBuilder<this["name"], this, {}, {}, ColumnSelector<this["name"], this, {}>, `${this["name"]}."${keyof this["columns"] & string}"`>;
 }
 
 declare function alias<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, NewAlias extends string>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, alias: NewAlias): QueryBuilder<NewAlias, TableRef, JoinedTables, Omit<Definition, "baseAlias"> & {
     baseAlias: NewAlias;
 }>;
-declare function clone<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): QueryBuilder<Alias, TableRef, JoinedTables, {}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>;
+declare function clone<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>;
 declare function rawCol<StrictAllowedColumn extends string, ColName extends StrictAllowedColumn = StrictAllowedColumn>(column: ColName): ColName;
 declare function col<StrictAllowedColumn extends string, ColName extends StrictAllowedColumn = StrictAllowedColumn, ColAlias extends string = string>(column: ColName, alias: ColAlias): {
     readonly column: ColName;
@@ -243,10 +275,10 @@ declare function rawWhere<Alias extends string, TableRef extends Table<string, R
 declare function rawOr<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: (c: typeof rawCol) => string, params?: any): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>;
 declare function rawHaving<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: (c: typeof rawCol) => string, params?: any): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>;
 declare function addCondition<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Clause extends ConditionClause, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator], Logical extends LogicalOperator, ValidClause extends Lowercase<Clause>>(query: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, clause: Clause, column: ColName, operator: Operator, value: Value, logical: Logical): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, ValidClause> & { [Key in ValidClause]: string[]; }, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>;
-declare function where<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+declare function where<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value?: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
     where: string[];
 }, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>;
-declare function or<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+declare function or<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value?: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
     where: string[];
 }, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>;
 declare function having<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "having"> & {
@@ -254,12 +286,12 @@ declare function having<Alias extends string, TableRef extends Table<string, Rec
 }, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>;
 
 interface QueryTransformerContract<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>> {
-    toQuery(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): {
+    toQuery(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, dialect?: Dialect | null): {
         query: string;
         params: unknown[] | null | undefined;
     };
     toString(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): string;
-    exec<This extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn> = QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, Output extends This['_output'] = This['_output']>(this: This): Promise<Output>;
+    exec<This extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn> = QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, Output extends This['_output'] = This['_output']>(this: This, tx?: TransactionSQL | null): Promise<Output>;
     clone(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>): typeof this;
     alias<NewAlias extends string>(alias: NewAlias): QueryBuilder<NewAlias, TableRef, JoinedTables, Omit<Definition, 'baseAlias'> & {
         baseAlias: NewAlias;
@@ -269,7 +301,9 @@ interface QueryConditionContract<Alias extends string, TableRef extends Table<st
     rawWhere(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: (c: typeof rawCol) => string, params?: any): ReturnType<typeof addRawCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.WHERE>>>;
     rawOr(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: (c: typeof rawCol) => string, params?: any): ReturnType<typeof addRawCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, typeof LogicalOperator.OR, Lowercase<typeof ConditionClause.WHERE>>>;
     rawHaving(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: (c: typeof rawCol) => string, params?: any): ReturnType<typeof addRawCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.HAVING, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.HAVING>>>;
+    where<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends typeof AcceptedOperator.IS_NULL | typeof AcceptedOperator.IS_NOT_NULL, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.WHERE>>>;
     where<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value: Value): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.WHERE>>>;
+    or<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends typeof AcceptedOperator.IS_NULL | typeof AcceptedOperator.IS_NOT_NULL, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.OR, Lowercase<typeof ConditionClause.WHERE>>>;
     or<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value: Value): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.WHERE, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.OR, Lowercase<typeof ConditionClause.WHERE>>>;
     having<ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value: Value): ReturnType<typeof addCondition<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, typeof ConditionClause.HAVING, ColName, ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator, Value, typeof LogicalOperator.AND, Lowercase<typeof ConditionClause.HAVING>>>;
 }
@@ -355,4 +389,4 @@ declare class QueryBuilder<Alias extends TableRef['name'], TableRef extends Tabl
     infer(): this['_output'];
 }
 
-export { type AliasedColumn as A, addRawCondition as B, type ColumnSelector as C, type DatabaseDefinition as D, rawWhere as E, rawOr as F, rawHaving as G, addCondition as H, where as I, or as J, having as K, type QueryTransformerContract as L, type MergeTimestampParanoid as M, type QueryConditionContract as N, type PostgresConfig as P, type QueryDefinition as Q, type RawColumn as R, type SqliteConfig as S, Table as T, type WhereValue as W, type TimestampOptions as a, type DatabaseDialect as b, type StrictColumnSelector as c, QueryBuilder as d, type SelectableColumn as e, type QuerHooks as f, type DatabaseOptions as g, type QueryRunHooks as h, type AcceptedOrderBy as i, type AcceptedInsertValues as j, type AcceptedUpdateValues as k, type AggregateColumn as l, type SelectQueryOutput as m, type QueryOutput as n, type QueryRunHooksOptions as o, createdAt as p, deletedAt as q, defineColumns as r, type TableOptions as s, type TableOutput as t, updatedAt as u, alias as v, clone as w, rawCol as x, col as y, aggregateCol as z };
+export { type AliasedColumn as A, clone as B, type ColumnSelector as C, type DatabaseDefinition as D, type ExecOptions as E, rawCol as F, col as G, aggregateCol as H, addRawCondition as I, rawWhere as J, rawOr as K, rawHaving as L, type MergeTimestampParanoid as M, addCondition as N, where as O, type PostgresConfig as P, type QueryDefinition as Q, type RawColumn as R, type SqlConfigMapping as S, Table as T, or as U, having as V, type WhereValue as W, type QueryTransformerContract as X, type QueryConditionContract as Y, type TimestampOptions as a, type DatabaseDialect as b, type DatabaseExecOptions as c, type SqliteConfig as d, type StrictColumnSelector as e, QueryBuilder as f, type SelectableColumn as g, type QuerHooks as h, type DatabaseOptions as i, type QueryRunHooks as j, type AcceptedOrderBy as k, type AcceptedInsertValues as l, type AcceptedUpdateValues as m, type AggregateColumn as n, type SelectQueryOutput as o, type QueryOutput as p, type QueryRunHooksOptions as q, type SqlConfig as r, type MysqlConfig as s, createdAt as t, updatedAt as u, deletedAt as v, defineColumns as w, type TableOptions as x, type TableOutput as y, alias as z };

package/dist/{index.d.ts → esm/index.d.ts}

@@ -1,10 +1,11 @@
 export { Column } from './column/index.js';
-export { D as Database } from './index-DFrpzXEn.js';
+export { D as Database } from './index-BXOAxB_h.js';
 export { Migration } from './migration/index.js';
-export { d as QueryBuilder, T as Table } from './index-FMT0YEO7.js';
+export { f as QueryBuilder, T as Table } from './index-BdpoD4zk.js';
 import './table/constants.js';
 import './column/constants.js';
 import './column/types.js';
+import 'bun';
 import './query/constants.js';
 import './migration/type.js';
 import './types.js';

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+export { Column } from './column/index.js';
+export { Database } from './database/index.js';
+export { Migration } from './migration/index.js';
+export { QueryBuilder } from './query/index.js';
+export { Table } from './table/index.js';

package/dist/{migration → esm/migration}/index.d.ts

@@ -1,10 +1,11 @@
 import { Column } from '../column/index.js';
-import { D as Database } from '../index-DFrpzXEn.js';
-import { T as Table } from '../index-FMT0YEO7.js';
+import { D as Database } from '../index-BXOAxB_h.js';
+import { T as Table } from '../index-BdpoD4zk.js';
 import { Dialect } from '../table/constants.js';
 import { MigrationOptions, MigrationFn } from './type.js';
 import '../column/constants.js';
 import '../column/types.js';
+import 'bun';
 import '../query/constants.js';
 import '../types.js';