@ignisia/sql 0.2.2 → 0.3.0

package/dist/esm/column/constants.js

@@ -24,76 +24,131 @@ var AcceptedColumnTypes = {
 var ColumnTypeMapping = {
   [AcceptedColumnTypes.INTEGER]: {
     [Dialect.SQLITE]: "INTEGER",
-    [Dialect.POSTGRES]: "INTEGER"
+    [Dialect.POSTGRES]: "INTEGER",
+    [Dialect.MYSQL]: "INT"
   },
   [AcceptedColumnTypes.STRING]: {
     [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "VARCHAR"
+    [Dialect.POSTGRES]: "VARCHAR",
+    [Dialect.MYSQL]: "VARCHAR"
   },
   [AcceptedColumnTypes.BOOLEAN]: {
     [Dialect.SQLITE]: "INTEGER",
-    [Dialect.POSTGRES]: "BOOLEAN"
+    [Dialect.POSTGRES]: "BOOLEAN",
+    [Dialect.MYSQL]: "TINYINT"
   },
   [AcceptedColumnTypes.DATE]: {
     [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "DATE"
+    [Dialect.POSTGRES]: "DATE",
+    [Dialect.MYSQL]: "DATE"
   },
   [AcceptedColumnTypes.FLOAT]: {
     [Dialect.SQLITE]: "REAL",
-    [Dialect.POSTGRES]: "FLOAT"
+    [Dialect.POSTGRES]: "FLOAT",
+    [Dialect.MYSQL]: "FLOAT PRECISION"
   },
   [AcceptedColumnTypes.DECIMAL]: {
-    [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "DECIMAL"
+    [Dialect.SQLITE]: "NUMERIC",
+    [Dialect.POSTGRES]: "DECIMAL",
+    [Dialect.MYSQL]: "DECIMAL"
   },
   [AcceptedColumnTypes.BIGINT]: {
-    [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "BIGINT"
+    [Dialect.SQLITE]: "INTEGER",
+    [Dialect.POSTGRES]: "BIGINT",
+    [Dialect.MYSQL]: "BIGINT"
   },
   [AcceptedColumnTypes.TEXT]: {
     [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "TEXT"
+    [Dialect.POSTGRES]: "TEXT",
+    [Dialect.MYSQL]: "TEXT"
   },
   [AcceptedColumnTypes.BLOB]: {
     [Dialect.SQLITE]: "BLOB",
-    [Dialect.POSTGRES]: "BYTEA"
+    [Dialect.POSTGRES]: "BYTEA",
+    [Dialect.MYSQL]: "BLOB"
   },
   [AcceptedColumnTypes.JSON]: {
     [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "JSONB"
+    [Dialect.POSTGRES]: "JSONB",
+    [Dialect.MYSQL]: "JSON"
   },
   [AcceptedColumnTypes.VARCHAR]: {
-    [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "VARCHAR"
+    [Dialect.SQLITE]: "VARCHAR",
+    [Dialect.POSTGRES]: "VARCHAR",
+    [Dialect.MYSQL]: "VARCHAR"
   },
   [AcceptedColumnTypes.TIME]: {
     [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "TIME"
+    [Dialect.POSTGRES]: "TIME",
+    [Dialect.MYSQL]: "TIME"
   },
   [AcceptedColumnTypes.TIMESTAMP]: {
     [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "TIMESTAMP"
+    [Dialect.POSTGRES]: "TIMESTAMP",
+    [Dialect.MYSQL]: "DATETIME"
   },
   [AcceptedColumnTypes.DOUBLE]: {
     [Dialect.SQLITE]: "REAL",
-    [Dialect.POSTGRES]: "DOUBLE PRECISION"
+    [Dialect.POSTGRES]: "DOUBLE PRECISION",
+    [Dialect.MYSQL]: "DOUBLE PRECISION"
   },
   [AcceptedColumnTypes.DATETIME]: {
     [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "TIMESTAMP"
+    [Dialect.POSTGRES]: "TIMESTAMP",
+    [Dialect.MYSQL]: "DATETIME"
   },
   [AcceptedColumnTypes.DATEONLY]: {
     [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "DATE"
+    [Dialect.POSTGRES]: "DATE",
+    [Dialect.MYSQL]: "DATE"
   },
   [AcceptedColumnTypes.ENUM]: {
     [Dialect.SQLITE]: "TEXT",
-    [Dialect.POSTGRES]: "TEXT"
+    [Dialect.POSTGRES]: "TEXT",
+    [Dialect.MYSQL]: "TEXT"
   },
   [AcceptedColumnTypes.SERIAL]: {
-    [Dialect.SQLITE]: "INTEGER AUTOINCREMENT",
-    [Dialect.POSTGRES]: "SERIAL"
+    [Dialect.SQLITE]: "INTEGER",
+    [Dialect.POSTGRES]: "SERIAL",
+    [Dialect.MYSQL]: "INT"
+  }
+};
+var ColumnProperties = {
+  NOT_NULL: "NOT_NULL",
+  UNIQUE: "UNIQUE",
+  DEFAULT: "DEFAULT",
+  AUTO_INCREMENT: "AUTO_INCREMENT",
+  PRIMARY_KEY: "PRIMARY_KEY"
+};
+var ColumnPropertyMapping = {
+  [ColumnProperties.NOT_NULL]: {
+    [Dialect.SQLITE]: "NOT NULL",
+    [Dialect.POSTGRES]: "NOT NULL",
+    [Dialect.MYSQL]: "NOT NULL"
+  },
+  [ColumnProperties.UNIQUE]: {
+    [Dialect.SQLITE]: "UNIQUE",
+    [Dialect.POSTGRES]: "UNIQUE",
+    [Dialect.MYSQL]: "UNIQUE"
+  },
+  [ColumnProperties.DEFAULT]: {
+    [Dialect.SQLITE]: "DEFAULT",
+    [Dialect.POSTGRES]: "DEFAULT",
+    [Dialect.MYSQL]: "DEFAULT"
+  },
+  [ColumnProperties.AUTO_INCREMENT]: {
+    // sqlite does not support AUTOINCREMENT
+    [Dialect.SQLITE]: "AUTOINCREMENT",
+    // postgres does not support AUTOINCREMENT
+    [Dialect.POSTGRES]: "AUTOINCREMENT",
+    // Exists only for mysql since mysql supports AUTOINCREMENT
+    [Dialect.MYSQL]: "AUTO_INCREMENT"
+  },
+  [ColumnProperties.PRIMARY_KEY]: {
+    [Dialect.SQLITE]: "PRIMARY KEY",
+    [Dialect.POSTGRES]: "PRIMARY KEY",
+    [Dialect.MYSQL]: "PRIMARY KEY"
   }
 };
 
-export { AcceptedColumnTypes, ColumnTypeMapping };
+export { AcceptedColumnTypes, ColumnProperties, ColumnPropertyMapping, ColumnTypeMapping };

package/dist/esm/column/index.d.ts

@@ -31,6 +31,7 @@ declare class Column<Type extends AcceptedColumnTypes = AcceptedColumnTypes, Val
     dialect<DbDialect extends Dialect>(dialect: DbDialect): Column<Type, Values, Options, ColumnValue, Value, Definition & {
         dialect: DbDialect;
     }>;
+    clone(): Column<Type, Values, Options, ColumnValue, Value, {}>;
     toQuery(): {
         query: string;
         params: never[];

package/dist/esm/column/index.js

@@ -1,5 +1,7 @@
 import { Dialect } from '../table/constants.js';
+import { deepClone } from '../utilities.js';
 import { ColumnTypeMapping, AcceptedColumnTypes } from './constants.js';
+import { columnProperty } from './utils.js';
 
 // src/column/index.ts
 var Column = class _Column {
@@ -58,40 +60,58 @@ var Column = class _Column {
     this.definition.dialect = dialect;
     return this;
   }
+  clone() {
+    const column = new _Column({
+      type: this.type,
+      ...this.length && { length: this.length },
+      ...this.enums.length && { values: this.enums }
+    });
+    Object.assign(column.definition, deepClone(this.definition));
+    return column;
+  }
   toQuery() {
     if (!this.definition.dialect) {
       throw new Error("No DB Dialect defined");
     }
-    const correctType = ColumnTypeMapping[this.type][this.definition.dialect];
-    let sql = correctType + (this.length ? `(${this.length})` : "");
+    const type = ColumnTypeMapping[this.type][this.definition.dialect];
+    const properties = columnProperty(this.definition.dialect);
+    let sql = type + (this.length ? `(${this.length})` : "");
     if (this.definition.primaryKey) {
-      sql += " PRIMARY KEY";
+      sql += ` ${properties.PRIMARY_KEY}`;
     }
     if (this.definition.autoIncrement || this.type === AcceptedColumnTypes.SERIAL) {
       const isPrimaryKey = !!this.definition.primaryKey;
+      const sqls = [];
       if (this.definition.dialect === Dialect.POSTGRES) {
-        sql = `SERIAL${isPrimaryKey ? " PRIMARY KEY" : ""}`;
+        sqls.push(type);
+        if (isPrimaryKey) {
+          sqls.push(properties.PRIMARY_KEY);
+        }
+        sql = sqls.join(" ");
       } else {
         if (this.type !== AcceptedColumnTypes.SERIAL) {
-          sql += " AUTOINCREMENT";
+          sql += ` ${properties.AUTO_INCREMENT}`;
         } else {
-          const sqls = ["INTEGER", "PRIMARY KEY", "AUTOINCREMENT"];
-          if (!isPrimaryKey) sqls.splice(1, 1);
+          sqls.push(type);
+          if (isPrimaryKey) {
+            sqls.push(properties.PRIMARY_KEY);
+          }
+          sqls.push(properties.AUTO_INCREMENT);
           sql = sqls.join(" ");
         }
       }
     }
     if (this.definition.notNull) {
-      sql += " NOT NULL";
+      sql += ` ${properties.NOT_NULL}`;
     }
     if (this.definition.unique) {
-      sql += " UNIQUE";
+      sql += ` ${properties.UNIQUE}`;
     }
     if (this.definition.default !== void 0) {
       const value = this.definition.default;
       const isString = typeof this.definition.default === "string";
       const finalValue = isString ? `'${value}'` : value;
-      sql += ` DEFAULT ${finalValue}`;
+      sql += ` ${properties.DEFAULT} ${finalValue}`;
     }
     return { query: sql, params: [] };
   }

package/dist/esm/column/utils.d.ts

@@ -0,0 +1,133 @@
+import { Dialect } from '../table/constants.js';
+import { ColumnProperties } from './constants.js';
+
+declare function getColumnProperty<DbDialect extends Dialect>(dialect: DbDialect, property: ColumnProperties): ({
+    sqlite: string;
+    postgres: string;
+    mysql: string;
+} | {
+    sqlite: string;
+    postgres: string;
+    mysql: string;
+} | {
+    sqlite: string;
+    postgres: string;
+    mysql: string;
+} | {
+    sqlite: string;
+    postgres: string;
+    mysql: string;
+} | {
+    sqlite: string;
+    postgres: string;
+    mysql: string;
+})[DbDialect];
+declare function columnProperty<DbDialect extends Dialect>(dialect: DbDialect): {
+    NOT_NULL: ({
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    })[DbDialect];
+    UNIQUE: ({
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    })[DbDialect];
+    DEFAULT: ({
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    })[DbDialect];
+    AUTO_INCREMENT: ({
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    })[DbDialect];
+    PRIMARY_KEY: ({
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    } | {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    })[DbDialect];
+};
+
+export { columnProperty, getColumnProperty };

package/dist/esm/column/utils.js

@@ -0,0 +1,32 @@
+import { ColumnPropertyMapping, ColumnProperties } from './constants.js';
+
+// src/column/utils.ts
+function getColumnProperty(dialect, property) {
+  return ColumnPropertyMapping[property][dialect];
+}
+function columnProperty(dialect) {
+  return {
+    [ColumnProperties.NOT_NULL]: getColumnProperty(
+      dialect,
+      ColumnProperties.NOT_NULL
+    ),
+    [ColumnProperties.UNIQUE]: getColumnProperty(
+      dialect,
+      ColumnProperties.UNIQUE
+    ),
+    [ColumnProperties.DEFAULT]: getColumnProperty(
+      dialect,
+      ColumnProperties.DEFAULT
+    ),
+    [ColumnProperties.AUTO_INCREMENT]: getColumnProperty(
+      dialect,
+      ColumnProperties.AUTO_INCREMENT
+    ),
+    [ColumnProperties.PRIMARY_KEY]: getColumnProperty(
+      dialect,
+      ColumnProperties.PRIMARY_KEY
+    )
+  };
+}
+
+export { columnProperty, getColumnProperty };

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

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

package/dist/esm/database/alter.js

@@ -5,9 +5,9 @@ async function alterColumnType(tableName, columnName, newType) {
   if (this.dialect === Dialect.SQLITE) {
     throw new Error("SQLite does not support ALTER COLUMN TYPE directly.");
   }
-  await this.client.exec(
-    `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} TYPE ${newType}`
-  );
+  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;
@@ -16,9 +16,9 @@ async function setColumnDefault(tableName, columnName, value) {
   if (this.dialect === Dialect.SQLITE) {
     throw new Error("SQLite does not support ALTER COLUMN DEFAULT directly.");
   }
-  await this.client.exec(
-    `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET DEFAULT ${value}`
-  );
+  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
@@ -33,9 +33,9 @@ async function dropColumnDefault(tableName, columnName) {
   if (this.dialect === Dialect.SQLITE) {
     throw new Error("SQLite does not support DROP DEFAULT directly.");
   }
-  await this.client.exec(
-    `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP DEFAULT`
-  );
+  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
@@ -52,9 +52,9 @@ async function setColumnNotNull(tableName, columnName) {
       "SQLite does not support SET NOT NULL (requires table rebuild)"
     );
   }
-  await this.client.exec(
-    `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET NOT NULL`
-  );
+  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
@@ -71,9 +71,9 @@ async function dropColumnNotNull(tableName, columnName) {
       "SQLite does not support DROP NOT NULL (requires table rebuild)"
     );
   }
-  await this.client.exec(
-    `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP NOT NULL`
-  );
+  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

package/dist/esm/database/column.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 } from '../index-FMT0YEO7.js';
+import { T as Table, D as DatabaseDefinition } 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/esm/database/column.js

@@ -2,9 +2,9 @@ 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;
@@ -13,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];
@@ -25,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/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/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/esm/database/index.js

@@ -3,7 +3,7 @@ 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 { DatabasePsql, DatabaseSqlite } from './wrapper.js';
+import { DatabaseMysql, DatabasePsql, DatabaseSqlite } from './wrapper.js';
 
 // src/database/index.ts
 var Database = class _Database {
@@ -31,10 +31,11 @@ var Database = 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);
@@ -59,6 +60,18 @@ var Database = 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`);

package/dist/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/esm/database/table.js

@@ -16,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

@@ -1,5 +1,6 @@
+import 'bun';
 import '../column/index.js';
-export { D as DatabaseDefinition, b as DatabaseDialect, g as DatabaseOptions, P as PostgresConfig, S as SqliteConfig } from '../index-FMT0YEO7.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';