@ignisia/sql 0.2.0 → 0.2.2

package/dist/cjs/column/constants.js

@@ -0,0 +1,101 @@
+'use strict';
+
+var constants = require('../table/constants');
+
+const AcceptedColumnTypes = {
+  INTEGER: "INTEGER",
+  STRING: "STRING",
+  BOOLEAN: "BOOLEAN",
+  DATE: "DATE",
+  FLOAT: "FLOAT",
+  DECIMAL: "DECIMAL",
+  BIGINT: "BIGINT",
+  TEXT: "TEXT",
+  BLOB: "BLOB",
+  JSON: "JSON",
+  VARCHAR: "VARCHAR",
+  TIME: "TIME",
+  TIMESTAMP: "TIMESTAMP",
+  DOUBLE: "DOUBLE",
+  DATETIME: "DATETIME",
+  DATEONLY: "DATEONLY",
+  ENUM: "ENUM",
+  SERIAL: "SERIAL"
+};
+const ColumnTypeMapping = {
+  [AcceptedColumnTypes.INTEGER]: {
+    [constants.Dialect.SQLITE]: "INTEGER",
+    [constants.Dialect.POSTGRES]: "INTEGER"
+  },
+  [AcceptedColumnTypes.STRING]: {
+    [constants.Dialect.SQLITE]: "TEXT",
+    [constants.Dialect.POSTGRES]: "VARCHAR"
+  },
+  [AcceptedColumnTypes.BOOLEAN]: {
+    [constants.Dialect.SQLITE]: "INTEGER",
+    [constants.Dialect.POSTGRES]: "BOOLEAN"
+  },
+  [AcceptedColumnTypes.DATE]: {
+    [constants.Dialect.SQLITE]: "TEXT",
+    [constants.Dialect.POSTGRES]: "DATE"
+  },
+  [AcceptedColumnTypes.FLOAT]: {
+    [constants.Dialect.SQLITE]: "REAL",
+    [constants.Dialect.POSTGRES]: "FLOAT"
+  },
+  [AcceptedColumnTypes.DECIMAL]: {
+    [constants.Dialect.SQLITE]: "TEXT",
+    [constants.Dialect.POSTGRES]: "DECIMAL"
+  },
+  [AcceptedColumnTypes.BIGINT]: {
+    [constants.Dialect.SQLITE]: "TEXT",
+    [constants.Dialect.POSTGRES]: "BIGINT"
+  },
+  [AcceptedColumnTypes.TEXT]: {
+    [constants.Dialect.SQLITE]: "TEXT",
+    [constants.Dialect.POSTGRES]: "TEXT"
+  },
+  [AcceptedColumnTypes.BLOB]: {
+    [constants.Dialect.SQLITE]: "BLOB",
+    [constants.Dialect.POSTGRES]: "BYTEA"
+  },
+  [AcceptedColumnTypes.JSON]: {
+    [constants.Dialect.SQLITE]: "TEXT",
+    [constants.Dialect.POSTGRES]: "JSONB"
+  },
+  [AcceptedColumnTypes.VARCHAR]: {
+    [constants.Dialect.SQLITE]: "TEXT",
+    [constants.Dialect.POSTGRES]: "VARCHAR"
+  },
+  [AcceptedColumnTypes.TIME]: {
+    [constants.Dialect.SQLITE]: "TEXT",
+    [constants.Dialect.POSTGRES]: "TIME"
+  },
+  [AcceptedColumnTypes.TIMESTAMP]: {
+    [constants.Dialect.SQLITE]: "TEXT",
+    [constants.Dialect.POSTGRES]: "TIMESTAMP"
+  },
+  [AcceptedColumnTypes.DOUBLE]: {
+    [constants.Dialect.SQLITE]: "REAL",
+    [constants.Dialect.POSTGRES]: "DOUBLE PRECISION"
+  },
+  [AcceptedColumnTypes.DATETIME]: {
+    [constants.Dialect.SQLITE]: "TEXT",
+    [constants.Dialect.POSTGRES]: "TIMESTAMP"
+  },
+  [AcceptedColumnTypes.DATEONLY]: {
+    [constants.Dialect.SQLITE]: "TEXT",
+    [constants.Dialect.POSTGRES]: "DATE"
+  },
+  [AcceptedColumnTypes.ENUM]: {
+    [constants.Dialect.SQLITE]: "TEXT",
+    [constants.Dialect.POSTGRES]: "TEXT"
+  },
+  [AcceptedColumnTypes.SERIAL]: {
+    [constants.Dialect.SQLITE]: "INTEGER AUTOINCREMENT",
+    [constants.Dialect.POSTGRES]: "SERIAL"
+  }
+};
+
+exports.AcceptedColumnTypes = AcceptedColumnTypes;
+exports.ColumnTypeMapping = ColumnTypeMapping;

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

@@ -0,0 +1,42 @@
+import { Dialect } from '../table/constants.cjs';
+import { AcceptedColumnTypes } from './constants.cjs';
+import { ColumnOptions, AcceptedColumnTypeMap, EnumOptions, ColumnDefinition, ValueSelector } from './types.cjs';
+
+declare class Column<Type extends AcceptedColumnTypes = AcceptedColumnTypes, Values extends number | readonly string[] = Type extends typeof AcceptedColumnTypes.ENUM ? readonly string[] : number, Options extends ColumnOptions<Type, Values> = ColumnOptions<Type, Values>, ColumnValue extends AcceptedColumnTypeMap[Options['type']] = AcceptedColumnTypeMap[Options['type']], Value extends Options extends EnumOptions<infer Value> ? Value[number] : ColumnValue = ColumnValue, Definition extends Partial<ColumnDefinition<Value, Dialect>> = NonNullable<unknown>> {
+    readonly definition: Definition;
+    readonly type: Options['type'];
+    readonly length: number | null;
+    readonly enums: readonly Value[];
+    readonly _output: ValueSelector<Definition, Value>;
+    protected constructor(options: Options);
+    static define<Type extends AcceptedColumnTypes = AcceptedColumnTypes, Values extends number | readonly string[] = number | readonly string[], Options extends ColumnOptions<Type, Values> = ColumnOptions<Type, Values>>(options: Options): Column<AcceptedColumnTypes, number | readonly string[], Options, AcceptedColumnTypeMap[Options["type"]], Options extends EnumOptions<infer Value extends readonly string[]> ? Value[number] : AcceptedColumnTypeMap[Options["type"]], {}>;
+    autoIncrement(): Column<Type, Values, Options, ColumnValue, Value, Definition & {
+        autoIncrement: true;
+    }>;
+    primaryKey(): Column<Type, Values, Options, ColumnValue, Value, Definition & {
+        primaryKey: true;
+    }>;
+    notNull(): Column<Type, Values, Options, ColumnValue, Value, Definition & {
+        notNull: true;
+    }>;
+    unique(): Column<Type, Values, Options, ColumnValue, Value, Definition & {
+        unique: true;
+    }>;
+    comment<Comment extends string | null>(value: Comment): Column<Type, Values, Options, ColumnValue, Value, Definition & {
+        comment: Comment;
+    }>;
+    default<FinalValue extends ValueSelector<Definition, Value>>(value: FinalValue): Column<Type, Values, Options, ColumnValue, Value, Definition & {
+        default: FinalValue;
+    }>;
+    dialect<DbDialect extends Dialect>(dialect: DbDialect): Column<Type, Values, Options, ColumnValue, Value, Definition & {
+        dialect: DbDialect;
+    }>;
+    toQuery(): {
+        query: string;
+        params: never[];
+    };
+    toString(): string;
+    infer(): this['_output'];
+}
+
+export { Column };

package/dist/cjs/column/index.js

@@ -0,0 +1,107 @@
+'use strict';
+
+var constants$1 = require('../table/constants');
+var constants = require('./constants');
+
+class Column {
+  definition;
+  type;
+  length;
+  enums;
+  _output;
+  constructor(options) {
+    this.type = options.type;
+    this.enums = [];
+    this.length = null;
+    if ("length" in options) {
+      this.length = options.length;
+    }
+    if ("values" in options) {
+      this.enums = options.values;
+    }
+    this.definition = {
+      autoIncrement: false,
+      primaryKey: false,
+      notNull: false,
+      unique: false,
+      comment: null,
+      default: void 0
+    };
+  }
+  static define(options) {
+    return new Column(options);
+  }
+  autoIncrement() {
+    this.definition.autoIncrement = true;
+    return this;
+  }
+  primaryKey() {
+    this.definition.primaryKey = true;
+    return this;
+  }
+  notNull() {
+    this.definition.notNull = true;
+    return this;
+  }
+  unique() {
+    this.definition.unique = true;
+    return this;
+  }
+  comment(value) {
+    this.definition.comment = value;
+    return this;
+  }
+  default(value) {
+    this.definition.default = value;
+    return this;
+  }
+  dialect(dialect) {
+    this.definition.dialect = dialect;
+    return this;
+  }
+  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})` : "");
+    if (this.definition.primaryKey) {
+      sql += " PRIMARY KEY";
+    }
+    if (this.definition.autoIncrement || this.type === constants.AcceptedColumnTypes.SERIAL) {
+      const isPrimaryKey = !!this.definition.primaryKey;
+      if (this.definition.dialect === constants$1.Dialect.POSTGRES) {
+        sql = `SERIAL${isPrimaryKey ? " PRIMARY KEY" : ""}`;
+      } else {
+        if (this.type !== constants.AcceptedColumnTypes.SERIAL) {
+          sql += " AUTOINCREMENT";
+        } else {
+          const sqls = ["INTEGER", "PRIMARY KEY", "AUTOINCREMENT"];
+          if (!isPrimaryKey) sqls.splice(1, 1);
+          sql = sqls.join(" ");
+        }
+      }
+    }
+    if (this.definition.notNull) {
+      sql += " NOT NULL";
+    }
+    if (this.definition.unique) {
+      sql += " 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}`;
+    }
+    return { query: sql, params: [] };
+  }
+  toString() {
+    return this.toQuery().query;
+  }
+  infer() {
+    return null;
+  }
+}
+
+exports.Column = Column;

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

@@ -0,0 +1,43 @@
+import { Dialect } from '../table/constants.cjs';
+import { AcceptedColumnTypes } from './constants.cjs';
+
+interface ColumnDefinition<T, U extends Dialect | null = null> {
+    primaryKey: boolean;
+    autoIncrement: boolean;
+    notNull: boolean;
+    unique: boolean;
+    comment: string | null;
+    default: T | undefined;
+    dialect: U | null;
+}
+type ValueSelector<Definition extends Partial<ColumnDefinition<Value, Dialect>> | ColumnDefinition<Value, Dialect>, Value> = Definition['notNull'] extends true ? Value | (string & {}) : Value | (string & {}) | null;
+type AcceptedColumnTypeMap<T = any> = {
+    [K in AcceptedColumnTypes]: K extends typeof AcceptedColumnTypes.INTEGER | typeof AcceptedColumnTypes.BIGINT | typeof AcceptedColumnTypes.FLOAT | typeof AcceptedColumnTypes.DOUBLE | typeof AcceptedColumnTypes.DECIMAL | typeof AcceptedColumnTypes.SERIAL ? number : K extends typeof AcceptedColumnTypes.STRING | typeof AcceptedColumnTypes.TEXT | typeof AcceptedColumnTypes.VARCHAR ? string : K extends typeof AcceptedColumnTypes.BOOLEAN ? boolean : K extends typeof AcceptedColumnTypes.DATE | typeof AcceptedColumnTypes.TIME | typeof AcceptedColumnTypes.TIMESTAMP | typeof AcceptedColumnTypes.DATETIME | typeof AcceptedColumnTypes.DATEONLY ? Date : K extends typeof AcceptedColumnTypes.JSON ? object : K extends typeof AcceptedColumnTypes.BLOB ? Buffer : K extends typeof AcceptedColumnTypes.ENUM ? T[number][] : never;
+};
+type DateOptions = {
+    type: typeof AcceptedColumnTypes.DATE | typeof AcceptedColumnTypes.TIME | typeof AcceptedColumnTypes.TIMESTAMP | typeof AcceptedColumnTypes.DATETIME | typeof AcceptedColumnTypes.DATEONLY;
+};
+type NumberOptions<Length extends number = number> = {
+    type: typeof AcceptedColumnTypes.INTEGER | typeof AcceptedColumnTypes.BIGINT | typeof AcceptedColumnTypes.FLOAT | typeof AcceptedColumnTypes.DECIMAL | typeof AcceptedColumnTypes.DOUBLE | typeof AcceptedColumnTypes.SERIAL;
+    length?: Length;
+};
+type StringOptions<Length extends number = number> = {
+    type: typeof AcceptedColumnTypes.STRING | typeof AcceptedColumnTypes.VARCHAR | typeof AcceptedColumnTypes.TEXT;
+    length?: Length;
+};
+type EnumOptions<Values extends readonly string[]> = {
+    type: typeof AcceptedColumnTypes.ENUM;
+    values: Values;
+};
+type BooleanOptions = {
+    type: typeof AcceptedColumnTypes.BOOLEAN;
+};
+type JsonOptions = {
+    type: typeof AcceptedColumnTypes.JSON;
+};
+type BlobOptions = {
+    type: typeof AcceptedColumnTypes.BLOB;
+};
+type ColumnOptions<Type extends AcceptedColumnTypes, U extends number | readonly string[]> = Type extends typeof AcceptedColumnTypes.BLOB ? BlobOptions : Type extends typeof AcceptedColumnTypes.JSON ? JsonOptions : Type extends typeof AcceptedColumnTypes.BOOLEAN ? BooleanOptions : Type extends typeof AcceptedColumnTypes.DATE | typeof AcceptedColumnTypes.TIME | typeof AcceptedColumnTypes.TIMESTAMP | typeof AcceptedColumnTypes.DATETIME | typeof AcceptedColumnTypes.DATEONLY ? DateOptions : Type extends typeof AcceptedColumnTypes.STRING | typeof AcceptedColumnTypes.VARCHAR | typeof AcceptedColumnTypes.TEXT ? U extends number ? StringOptions<U> : StringOptions : Type extends typeof AcceptedColumnTypes.INTEGER | typeof AcceptedColumnTypes.BIGINT | typeof AcceptedColumnTypes.FLOAT | typeof AcceptedColumnTypes.DECIMAL | typeof AcceptedColumnTypes.DOUBLE | typeof AcceptedColumnTypes.SERIAL ? U extends number ? NumberOptions<U> : NumberOptions : Type extends typeof AcceptedColumnTypes.ENUM ? U extends readonly string[] ? EnumOptions<U> : never : never;
+
+export type { AcceptedColumnTypeMap, BlobOptions, BooleanOptions, ColumnDefinition, ColumnOptions, DateOptions, EnumOptions, JsonOptions, NumberOptions, StringOptions, ValueSelector };

package/dist/cjs/column/types.js

@@ -0,0 +1,4 @@
+'use strict';
+
+require('./constants');
+

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

@@ -0,0 +1,52 @@
+import { D as Database } from '../index---zaMa69.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 { Dialect } from '../table/constants.cjs';
+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(
+    `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(
+    `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(
+    `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(
+    `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(
+    `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,24 @@
+import { D as Database } from '../index---zaMa69.cjs';
+import { Column } from '../column/index.cjs';
+import { T as Table, D as DatabaseDefinition } from '../index-CwiFQh0I.cjs';
+import { Dialect } from '../table/constants.cjs';
+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,37 @@
+'use strict';
+
+var constants = require('../table/constants');
+
+async function addColumn(tableName, columnName, column) {
+  await this.client.exec(
+    `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(
+    `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(`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,8 @@
+export { C as ColumnAlterationContract, T as TableAlterationContract } from '../index---zaMa69.cjs';
+import '../column/index.cjs';
+import '../column/constants.cjs';
+import '../index-CwiFQh0I.cjs';
+import '../table/constants.cjs';
+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,8 @@
+import '../column/index.cjs';
+import '../index-CwiFQh0I.cjs';
+import '../query/constants.cjs';
+import '../table/constants.cjs';
+export { D as Database } from '../index---zaMa69.cjs';
+import '../column/constants.cjs';
+import '../column/types.cjs';
+import '../types.cjs';

package/dist/cjs/database/index.js

@@ -0,0 +1,94 @@
+'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 = options.dialect === constants.Dialect.POSTGRES ? new wrapper.DatabasePsql(options.config) : new wrapper.DatabaseSqlite(options.config);
+    if (options.tables) {
+      for (const tableName in options.tables) {
+        options.tables[tableName].client = this.client;
+      }
+    }
+    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
+    );
+  }
+  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,21 @@
+import { D as Database } from '../index---zaMa69.cjs';
+import { Column } from '../column/index.cjs';
+import { T as Table, D as DatabaseDefinition, a as TimestampOptions, M as MergeTimestampParanoid } from '../index-CwiFQh0I.cjs';
+import { Dialect } from '../table/constants.cjs';
+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 };