@ignisia/sql 0.2.2 → 0.4.0

package/README.md

@@ -6,6 +6,7 @@ Type-safe SQL query builder for Bun SQL and SQLite.
 
 - [Bun](https://bun.sh/)
 - [PostgreSQL](https://www.postgresql.org/) (optional, only for PostgreSQL dialect)
+- [MySQL](https://www.mysql.com/) (optional, only for MySQL dialect)
 
 ## Installation
 
@@ -21,7 +22,6 @@ import { Table, Column, Database } from '@ignisia/sql';
 // Define a table
 const users = Table.define({
   name: 'users',
-  dialect: 'postgres',
   columns: {
     // Define a column called "id"
     id: Column.define({

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

@@ -23,75 +23,128 @@ declare const ColumnTypeMapping: {
     readonly INTEGER: {
         readonly sqlite: "INTEGER";
         readonly postgres: "INTEGER";
+        readonly mysql: "INT";
     };
     readonly STRING: {
         readonly sqlite: "TEXT";
         readonly postgres: "VARCHAR";
+        readonly mysql: "VARCHAR";
     };
     readonly BOOLEAN: {
         readonly sqlite: "INTEGER";
         readonly postgres: "BOOLEAN";
+        readonly mysql: "TINYINT";
     };
     readonly DATE: {
         readonly sqlite: "TEXT";
         readonly postgres: "DATE";
+        readonly mysql: "DATE";
     };
     readonly FLOAT: {
         readonly sqlite: "REAL";
         readonly postgres: "FLOAT";
+        readonly mysql: "FLOAT PRECISION";
     };
     readonly DECIMAL: {
-        readonly sqlite: "TEXT";
+        readonly sqlite: "NUMERIC";
         readonly postgres: "DECIMAL";
+        readonly mysql: "DECIMAL";
     };
     readonly BIGINT: {
-        readonly sqlite: "TEXT";
+        readonly sqlite: "INTEGER";
         readonly postgres: "BIGINT";
+        readonly mysql: "BIGINT";
     };
     readonly TEXT: {
         readonly sqlite: "TEXT";
         readonly postgres: "TEXT";
+        readonly mysql: "TEXT";
     };
     readonly BLOB: {
         readonly sqlite: "BLOB";
         readonly postgres: "BYTEA";
+        readonly mysql: "BLOB";
     };
     readonly JSON: {
         readonly sqlite: "TEXT";
         readonly postgres: "JSONB";
+        readonly mysql: "JSON";
     };
     readonly VARCHAR: {
-        readonly sqlite: "TEXT";
+        readonly sqlite: "VARCHAR";
         readonly postgres: "VARCHAR";
+        readonly mysql: "VARCHAR";
     };
     readonly TIME: {
         readonly sqlite: "TEXT";
         readonly postgres: "TIME";
+        readonly mysql: "TIME";
     };
     readonly TIMESTAMP: {
         readonly sqlite: "TEXT";
         readonly postgres: "TIMESTAMP";
+        readonly mysql: "DATETIME";
     };
     readonly DOUBLE: {
         readonly sqlite: "REAL";
         readonly postgres: "DOUBLE PRECISION";
+        readonly mysql: "DOUBLE PRECISION";
     };
     readonly DATETIME: {
         readonly sqlite: "TEXT";
         readonly postgres: "TIMESTAMP";
+        readonly mysql: "DATETIME";
     };
     readonly DATEONLY: {
         readonly sqlite: "TEXT";
         readonly postgres: "DATE";
+        readonly mysql: "DATE";
     };
     readonly ENUM: {
         readonly sqlite: "TEXT";
         readonly postgres: "TEXT";
+        readonly mysql: "TEXT";
     };
     readonly SERIAL: {
-        readonly sqlite: "INTEGER AUTOINCREMENT";
+        readonly sqlite: "INTEGER";
         readonly postgres: "SERIAL";
+        readonly mysql: "INT";
+    };
+};
+declare const ColumnProperties: {
+    readonly NOT_NULL: "NOT_NULL";
+    readonly UNIQUE: "UNIQUE";
+    readonly DEFAULT: "DEFAULT";
+    readonly AUTO_INCREMENT: "AUTO_INCREMENT";
+    readonly PRIMARY_KEY: "PRIMARY_KEY";
+};
+type ColumnProperties = (typeof ColumnProperties)[keyof typeof ColumnProperties];
+declare const ColumnPropertyMapping: {
+    NOT_NULL: {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    };
+    UNIQUE: {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    };
+    DEFAULT: {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    };
+    AUTO_INCREMENT: {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
+    };
+    PRIMARY_KEY: {
+        sqlite: string;
+        postgres: string;
+        mysql: string;
     };
 };
 
-export { AcceptedColumnTypes, ColumnTypeMapping };
+export { AcceptedColumnTypes, ColumnProperties, ColumnPropertyMapping, ColumnTypeMapping };

package/dist/cjs/column/constants.js

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

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

@@ -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/cjs/column/index.js

@@ -1,7 +1,9 @@
 'use strict';
 
 var constants$1 = require('../table/constants');
+var utilities = require('../utilities');
 var constants = require('./constants');
+var utils = require('./utils');
 
 class Column {
   definition;
@@ -19,14 +21,7 @@ class Column {
     if ("values" in options) {
       this.enums = options.values;
     }
-    this.definition = {
-      autoIncrement: false,
-      primaryKey: false,
-      notNull: false,
-      unique: false,
-      comment: null,
-      default: void 0
-    };
+    this.definition = {};
   }
   static define(options) {
     return new Column(options);
@@ -59,40 +54,58 @@ 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, utilities.cloneDefinition(this.definition));
+    return column;
+  }
   toQuery() {
     if (!this.definition.dialect) {
       throw new Error("No DB Dialect defined");
     }
-    const correctType = constants.ColumnTypeMapping[this.type][this.definition.dialect];
-    let sql = correctType + (this.length ? `(${this.length})` : "");
+    const type = constants.ColumnTypeMapping[this.type][this.definition.dialect];
+    const properties = utils.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 === constants.AcceptedColumnTypes.SERIAL) {
       const isPrimaryKey = !!this.definition.primaryKey;
+      const sqls = [];
       if (this.definition.dialect === constants$1.Dialect.POSTGRES) {
-        sql = `SERIAL${isPrimaryKey ? " PRIMARY KEY" : ""}`;
+        sqls.push(type);
+        if (isPrimaryKey) {
+          sqls.push(properties.PRIMARY_KEY);
+        }
+        sql = sqls.join(" ");
       } else {
         if (this.type !== constants.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/cjs/column/utils.d.cts

@@ -0,0 +1,133 @@
+import { Dialect } from '../table/constants.cjs';
+import { ColumnProperties } from './constants.cjs';
+
+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/cjs/column/utils.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var constants = require('./constants');
+
+function getColumnProperty(dialect, property) {
+  return constants.ColumnPropertyMapping[property][dialect];
+}
+function columnProperty(dialect) {
+  return {
+    [constants.ColumnProperties.NOT_NULL]: getColumnProperty(
+      dialect,
+      constants.ColumnProperties.NOT_NULL
+    ),
+    [constants.ColumnProperties.UNIQUE]: getColumnProperty(
+      dialect,
+      constants.ColumnProperties.UNIQUE
+    ),
+    [constants.ColumnProperties.DEFAULT]: getColumnProperty(
+      dialect,
+      constants.ColumnProperties.DEFAULT
+    ),
+    [constants.ColumnProperties.AUTO_INCREMENT]: getColumnProperty(
+      dialect,
+      constants.ColumnProperties.AUTO_INCREMENT
+    ),
+    [constants.ColumnProperties.PRIMARY_KEY]: getColumnProperty(
+      dialect,
+      constants.ColumnProperties.PRIMARY_KEY
+    )
+  };
+}
+
+exports.columnProperty = columnProperty;
+exports.getColumnProperty = getColumnProperty;

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

@@ -1,8 +1,9 @@
-import { D as Database } from '../index---zaMa69.cjs';
+import { D as Database } from '../index-CZhrzE5r.cjs';
 import { Column } from '../column/index.cjs';
 import { AcceptedColumnTypes } from '../column/constants.cjs';
-import { T as Table, D as DatabaseDefinition } from '../index-CwiFQh0I.cjs';
+import { T as Table, D as DatabaseDefinition } from '../index-CHxuUiO4.cjs';
 import { Dialect } from '../table/constants.cjs';
+import 'bun';
 import '../query/constants.cjs';
 import '../column/types.cjs';
 import '../types.cjs';

package/dist/cjs/database/alter.js

@@ -6,9 +6,9 @@ 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(
-    `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;
@@ -17,9 +17,9 @@ 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(
-    `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
@@ -34,9 +34,9 @@ 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(
-    `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
@@ -53,9 +53,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
@@ -72,9 +72,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/cjs/database/column.d.cts

@@ -1,7 +1,8 @@
-import { D as Database } from '../index---zaMa69.cjs';
+import { D as Database } from '../index-CZhrzE5r.cjs';
 import { Column } from '../column/index.cjs';
-import { T as Table, D as DatabaseDefinition } from '../index-CwiFQh0I.cjs';
+import { T as Table, D as DatabaseDefinition } from '../index-CHxuUiO4.cjs';
 import { Dialect } from '../table/constants.cjs';
+import 'bun';
 import '../query/constants.cjs';
 import '../column/constants.cjs';
 import '../column/types.cjs';