@ignisia/sql 0.1.0

package/dist/chunk-V4OMHVJN.js

@@ -0,0 +1,96 @@
+import {
+  Dialect
+} from "./chunk-GLOHF5CP.js";
+
+// src/database/alter.ts
+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}`
+  );
+  if (!this.tables[tableName]) return this;
+  this.tables[tableName].columns[columnName].type = newType;
+  return this;
+}
+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}`
+  );
+  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 === 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 === 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 === 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;
+}
+
+export {
+  alterColumnType,
+  setColumnDefault,
+  dropColumnDefault,
+  setColumnNotNull,
+  dropColumnNotNull
+};

package/dist/chunk-W2DR3ZVK.js

@@ -0,0 +1,59 @@
+import {
+  QueryBuilder
+} from "./chunk-TQ2GXAE7.js";
+import {
+  defineColumns
+} from "./chunk-WVJGTZFI.js";
+
+// src/table/index.ts
+var Table = class _Table {
+  database;
+  dialect;
+  name;
+  columns;
+  timestamp;
+  paranoid;
+  _output;
+  constructor(options) {
+    this.dialect = options.dialect;
+    this.name = options.name;
+    this.columns = options.columns;
+    this.paranoid = options.paranoid || null;
+    this.timestamp = options.timestamp || null;
+    this.database = null;
+    for (const column of Object.values(this.columns)) {
+      column.dialect(options.dialect);
+    }
+  }
+  infer() {
+    return null;
+  }
+  static define(options) {
+    const columns = defineColumns(options);
+    return new _Table({
+      ...options,
+      columns
+    });
+  }
+  async create(db = this.database) {
+    if (!db) throw new Error("Database client not defined");
+    const sql = `CREATE TABLE IF NOT EXISTS ${this.name} (${Object.entries(
+      this.columns
+    ).map(([name, column]) => `${name} ${column.toQuery().query}`).join(", ")});`;
+    await db.exec(sql);
+    return this;
+  }
+  async drop(db = this.database) {
+    if (!db) throw new Error("Database client not defined");
+    const sql = `DROP TABLE IF EXISTS ${this.name};`;
+    await db.exec(sql);
+    return this;
+  }
+  query() {
+    return new QueryBuilder(this);
+  }
+};
+
+export {
+  Table
+};

package/dist/chunk-WVJGTZFI.js

@@ -0,0 +1,60 @@
+import {
+  Column
+} from "./chunk-GY7R637S.js";
+
+// src/table/utilities.ts
+var createdAt = Column.define({
+  type: "DATETIME"
+}).default("CURRENT_TIMESTAMP");
+var updatedAt = Column.define({
+  type: "DATETIME"
+});
+var deletedAt = Column.define({
+  type: "DATETIME"
+});
+function defineColumns(options) {
+  const columns = {
+    ...options.columns
+  };
+  const tracker = {
+    createdAt: "createdAt",
+    updatedAt: "updatedAt",
+    deletedAt: "deletedAt"
+  };
+  if (options.timestamp) {
+    const timestamp = {
+      createdAt: "createdAt",
+      updatedAt: "updatedAt"
+    };
+    if (typeof options.timestamp === "object") {
+      if (typeof options.timestamp.createdAt === "string") {
+        timestamp.createdAt = options.timestamp.createdAt;
+      }
+      if (typeof options.timestamp.updatedAt === "string") {
+        timestamp.updatedAt = options.timestamp.updatedAt;
+      }
+    }
+    if (!columns[timestamp.createdAt]) {
+      columns[timestamp.createdAt] = createdAt;
+    }
+    if (!columns[timestamp.updatedAt]) {
+      columns[timestamp.updatedAt] = updatedAt;
+    }
+  }
+  if (options.paranoid) {
+    if (typeof options.paranoid !== "boolean") {
+      tracker.deletedAt = options.paranoid;
+    }
+    if (!columns[tracker.deletedAt]) {
+      columns[tracker.deletedAt] = deletedAt;
+    }
+  }
+  return columns;
+}
+
+export {
+  createdAt,
+  updatedAt,
+  deletedAt,
+  defineColumns
+};

package/dist/chunk-Y7FSRHH3.js

@@ -0,0 +1,22 @@
+// src/utilities.ts
+function deepClone(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (obj && typeof obj === "object") {
+    const clonedObj = {};
+    for (const key in obj) {
+      clonedObj[key] = deepClone(obj[key]);
+    }
+    return clonedObj;
+  }
+  return obj;
+}
+function quoteIdentifier(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+
+export {
+  deepClone,
+  quoteIdentifier
+};

package/dist/column/constants.d.ts

@@ -0,0 +1,97 @@
+declare const AcceptedColumnTypes: {
+    readonly INTEGER: "INTEGER";
+    readonly STRING: "STRING";
+    readonly BOOLEAN: "BOOLEAN";
+    readonly DATE: "DATE";
+    readonly FLOAT: "FLOAT";
+    readonly DECIMAL: "DECIMAL";
+    readonly BIGINT: "BIGINT";
+    readonly TEXT: "TEXT";
+    readonly BLOB: "BLOB";
+    readonly JSON: "JSON";
+    readonly VARCHAR: "VARCHAR";
+    readonly TIME: "TIME";
+    readonly TIMESTAMP: "TIMESTAMP";
+    readonly DOUBLE: "DOUBLE";
+    readonly DATETIME: "DATETIME";
+    readonly DATEONLY: "DATEONLY";
+    readonly ENUM: "ENUM";
+    readonly SERIAL: "SERIAL";
+};
+type AcceptedColumnTypes = (typeof AcceptedColumnTypes)[keyof typeof AcceptedColumnTypes];
+declare const ColumnTypeMapping: {
+    readonly INTEGER: {
+        readonly sqlite: "INTEGER";
+        readonly postgres: "INTEGER";
+    };
+    readonly STRING: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "VARCHAR";
+    };
+    readonly BOOLEAN: {
+        readonly sqlite: "INTEGER";
+        readonly postgres: "BOOLEAN";
+    };
+    readonly DATE: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "DATE";
+    };
+    readonly FLOAT: {
+        readonly sqlite: "REAL";
+        readonly postgres: "FLOAT";
+    };
+    readonly DECIMAL: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "DECIMAL";
+    };
+    readonly BIGINT: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "BIGINT";
+    };
+    readonly TEXT: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "TEXT";
+    };
+    readonly BLOB: {
+        readonly sqlite: "BLOB";
+        readonly postgres: "BYTEA";
+    };
+    readonly JSON: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "JSONB";
+    };
+    readonly VARCHAR: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "VARCHAR";
+    };
+    readonly TIME: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "TIME";
+    };
+    readonly TIMESTAMP: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "TIMESTAMP";
+    };
+    readonly DOUBLE: {
+        readonly sqlite: "REAL";
+        readonly postgres: "DOUBLE PRECISION";
+    };
+    readonly DATETIME: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "TIMESTAMP";
+    };
+    readonly DATEONLY: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "DATE";
+    };
+    readonly ENUM: {
+        readonly sqlite: "TEXT";
+        readonly postgres: "TEXT";
+    };
+    readonly SERIAL: {
+        readonly sqlite: "INTEGER AUTOINCREMENT";
+        readonly postgres: "SERIAL";
+    };
+};
+
+export { AcceptedColumnTypes, ColumnTypeMapping };

package/dist/column/constants.js

@@ -0,0 +1,9 @@
+import {
+  AcceptedColumnTypes,
+  ColumnTypeMapping
+} from "../chunk-G3LSCLIQ.js";
+import "../chunk-GLOHF5CP.js";
+export {
+  AcceptedColumnTypes,
+  ColumnTypeMapping
+};

package/dist/column/index.d.ts

@@ -0,0 +1,42 @@
+import { Dialect } from '../table/constants.js';
+import { AcceptedColumnTypes } from './constants.js';
+import { ColumnOptions, AcceptedColumnTypeMap, EnumOptions, ColumnDefinition, ValueSelector } from './types.js';
+
+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/column/index.js

@@ -0,0 +1,8 @@
+import {
+  Column
+} from "../chunk-GY7R637S.js";
+import "../chunk-G3LSCLIQ.js";
+import "../chunk-GLOHF5CP.js";
+export {
+  Column
+};

package/dist/column/types.d.ts

@@ -0,0 +1,43 @@
+import { Dialect } from '../table/constants.js';
+import { AcceptedColumnTypes } from './constants.js';
+
+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/column/types.js

@@ -0,0 +1,2 @@
+import "../chunk-G3LSCLIQ.js";
+import "../chunk-GLOHF5CP.js";

package/dist/database/alter.d.ts

@@ -0,0 +1,52 @@
+import { D as Database } from '../index-Dcm5xIpR.js';
+import { Column } from '../column/index.js';
+import { AcceptedColumnTypes } from '../column/constants.js';
+import { T as Table, D as DatabaseDefinition } from '../index-DJhQVUY3.js';
+import { Dialect } from '../table/constants.js';
+import '../column/types.js';
+import '../types.js';
+import '../query/constants.js';
+
+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/database/alter.js

@@ -0,0 +1,15 @@
+import {
+  alterColumnType,
+  dropColumnDefault,
+  dropColumnNotNull,
+  setColumnDefault,
+  setColumnNotNull
+} from "../chunk-V4OMHVJN.js";
+import "../chunk-GLOHF5CP.js";
+export {
+  alterColumnType,
+  dropColumnDefault,
+  dropColumnNotNull,
+  setColumnDefault,
+  setColumnNotNull
+};

package/dist/database/column.d.ts

@@ -0,0 +1,24 @@
+import { D as Database } from '../index-Dcm5xIpR.js';
+import { Column } from '../column/index.js';
+import { T as Table, D as DatabaseDefinition } from '../index-DJhQVUY3.js';
+import { Dialect } from '../table/constants.js';
+import '../column/constants.js';
+import '../column/types.js';
+import '../types.js';
+import '../query/constants.js';
+
+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/database/column.js

@@ -0,0 +1,11 @@
+import {
+  addColumn,
+  dropColumn,
+  renameColumn
+} from "../chunk-JF7OSNH4.js";
+import "../chunk-GLOHF5CP.js";
+export {
+  addColumn,
+  dropColumn,
+  renameColumn
+};

package/dist/database/contract.d.ts

@@ -0,0 +1,8 @@
+export { C as ColumnAlterationContract, T as TableAlterationContract } from '../index-Dcm5xIpR.js';
+import '../column/index.js';
+import '../column/constants.js';
+import '../index-DJhQVUY3.js';
+import '../table/constants.js';
+import '../column/types.js';
+import '../types.js';
+import '../query/constants.js';

package/dist/database/index.d.ts

@@ -0,0 +1,8 @@
+import '../column/index.js';
+import '../index-DJhQVUY3.js';
+import '../table/constants.js';
+export { D as Database } from '../index-Dcm5xIpR.js';
+import '../column/constants.js';
+import '../column/types.js';
+import '../types.js';
+import '../query/constants.js';

package/dist/database/index.js

@@ -0,0 +1,19 @@
+import {
+  Database
+} from "../chunk-4DQRB5XS.js";
+import "../chunk-HKTHKQLK.js";
+import "../chunk-JF7OSNH4.js";
+import "../chunk-D2ASIT4Q.js";
+import "../chunk-W2DR3ZVK.js";
+import "../chunk-TQ2GXAE7.js";
+import "../chunk-MG2S4V4N.js";
+import "../chunk-FYSNJAGD.js";
+import "../chunk-WVJGTZFI.js";
+import "../chunk-GY7R637S.js";
+import "../chunk-G3LSCLIQ.js";
+import "../chunk-Y7FSRHH3.js";
+import "../chunk-V4OMHVJN.js";
+import "../chunk-GLOHF5CP.js";
+export {
+  Database
+};

package/dist/database/table.d.ts

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

package/dist/database/table.js

@@ -0,0 +1,19 @@
+import {
+  createTable,
+  dropTable,
+  renameTable
+} from "../chunk-D2ASIT4Q.js";
+import "../chunk-W2DR3ZVK.js";
+import "../chunk-TQ2GXAE7.js";
+import "../chunk-MG2S4V4N.js";
+import "../chunk-FYSNJAGD.js";
+import "../chunk-WVJGTZFI.js";
+import "../chunk-GY7R637S.js";
+import "../chunk-G3LSCLIQ.js";
+import "../chunk-Y7FSRHH3.js";
+import "../chunk-GLOHF5CP.js";
+export {
+  createTable,
+  dropTable,
+  renameTable
+};

package/dist/database/types.d.ts

@@ -0,0 +1,7 @@
+import '../column/index.js';
+export { D as DatabaseDefinition, b as DatabaseDialect, f as DatabaseOptions, P as PostgresConfig, S as SqliteConfig } from '../index-DJhQVUY3.js';
+import '../table/constants.js';
+import '../column/constants.js';
+import '../column/types.js';
+import '../types.js';
+import '../query/constants.js';