@ignisia/sql 0.1.0 → 0.2.1

package/README.md

@@ -19,14 +19,14 @@ bun add @ignisia/sql
 import { Table, Column, Database } from '@ignisia/sql';
 
 // Define a table
-const users = Table.define(
+const users = Table.define({
   name: 'users',
+  dialect: 'postgres',
   columns: {
     // Define a column called "id"
     id: Column.define({
       type: 'SERIAL',
-    })
-      .primaryKey(),
+    }).primaryKey(),
     name: Column.define({
       type: 'TEXT',
       length: 255,
@@ -47,7 +47,7 @@ const users = Table.define(
   // By default the name of the created at column called "createdAt" and the name of the updated at column called "updatedAt"
   // Pass an object with `createdAt` and `updatedAt` to rename them
   timestamp: true,
-);
+});
 
 // Define a database
 const db = Database.define({
@@ -57,7 +57,7 @@ const db = Database.define({
   config: {
     host: 'localhost',
     port: 5432,
-    username: 'postgres',
+    user: 'postgres',
     password: 'postgres',
     database: 'my_database',
   },
@@ -65,13 +65,13 @@ const db = Database.define({
   //  This will automatically assign db properties to each table so it can do query
   tables: {
     users,
-  }
+  },
 });
 
 // Using the database
 
 // Fetch all users
-const listUsers = await db.table('users').select().query()
+const listUsers = await db.table('users').select().query();
 // ^ Add .limit before the .query() to limit the number of results
 // ^ Add .offset before the .query() to offset the results
 // ^ Add .orderBy before the .query() to order the results
@@ -93,7 +93,7 @@ const newUsers = await db.table('users').insert(
 );
 
 // Delete a user
-const deletedUsers = await db.table('users').delete()
+const deletedUsers = await db.table('users').delete();
 // ^ Add .where before the .query() to filter the deleted rows
 
 // Update a user

package/dist/column/constants.js

@@ -1,9 +1,98 @@
-import {
-  AcceptedColumnTypes,
-  ColumnTypeMapping
-} from "../chunk-G3LSCLIQ.js";
-import "../chunk-GLOHF5CP.js";
-export {
-  AcceptedColumnTypes,
-  ColumnTypeMapping
+import { Dialect } from '../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]: {
+    [Dialect.SQLITE]: "INTEGER",
+    [Dialect.POSTGRES]: "INTEGER"
+  },
+  [AcceptedColumnTypes.STRING]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "VARCHAR"
+  },
+  [AcceptedColumnTypes.BOOLEAN]: {
+    [Dialect.SQLITE]: "INTEGER",
+    [Dialect.POSTGRES]: "BOOLEAN"
+  },
+  [AcceptedColumnTypes.DATE]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "DATE"
+  },
+  [AcceptedColumnTypes.FLOAT]: {
+    [Dialect.SQLITE]: "REAL",
+    [Dialect.POSTGRES]: "FLOAT"
+  },
+  [AcceptedColumnTypes.DECIMAL]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "DECIMAL"
+  },
+  [AcceptedColumnTypes.BIGINT]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "BIGINT"
+  },
+  [AcceptedColumnTypes.TEXT]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "TEXT"
+  },
+  [AcceptedColumnTypes.BLOB]: {
+    [Dialect.SQLITE]: "BLOB",
+    [Dialect.POSTGRES]: "BYTEA"
+  },
+  [AcceptedColumnTypes.JSON]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "JSONB"
+  },
+  [AcceptedColumnTypes.VARCHAR]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "VARCHAR"
+  },
+  [AcceptedColumnTypes.TIME]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "TIME"
+  },
+  [AcceptedColumnTypes.TIMESTAMP]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "TIMESTAMP"
+  },
+  [AcceptedColumnTypes.DOUBLE]: {
+    [Dialect.SQLITE]: "REAL",
+    [Dialect.POSTGRES]: "DOUBLE PRECISION"
+  },
+  [AcceptedColumnTypes.DATETIME]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "TIMESTAMP"
+  },
+  [AcceptedColumnTypes.DATEONLY]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "DATE"
+  },
+  [AcceptedColumnTypes.ENUM]: {
+    [Dialect.SQLITE]: "TEXT",
+    [Dialect.POSTGRES]: "TEXT"
+  },
+  [AcceptedColumnTypes.SERIAL]: {
+    [Dialect.SQLITE]: "INTEGER AUTOINCREMENT",
+    [Dialect.POSTGRES]: "SERIAL"
+  }
+};
+
+export { AcceptedColumnTypes, ColumnTypeMapping };

package/dist/column/index.js

@@ -1,8 +1,105 @@
-import {
-  Column
-} from "../chunk-GY7R637S.js";
-import "../chunk-G3LSCLIQ.js";
-import "../chunk-GLOHF5CP.js";
-export {
-  Column
-};
+import { Dialect } from '../table/constants';
+import { ColumnTypeMapping, AcceptedColumnTypes } from './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 = 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 === AcceptedColumnTypes.SERIAL) {
+      const isPrimaryKey = !!this.definition.primaryKey;
+      if (this.definition.dialect === Dialect.POSTGRES) {
+        sql = `SERIAL${isPrimaryKey ? " PRIMARY KEY" : ""}`;
+      } else {
+        if (this.type !== 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;
+  }
+}
+
+export { Column };

package/dist/column/types.js

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

package/dist/database/alter.d.ts

@@ -1,11 +1,11 @@
-import { D as Database } from '../index-Dcm5xIpR.js';
+import { D as Database } from '../index-DFrpzXEn.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 { T as Table, D as DatabaseDefinition } from '../index-FMT0YEO7.js';
 import { Dialect } from '../table/constants.js';
+import '../query/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> & {

package/dist/database/alter.js

@@ -1,15 +1,87 @@
-import {
-  alterColumnType,
-  dropColumnDefault,
-  dropColumnNotNull,
-  setColumnDefault,
-  setColumnNotNull
-} from "../chunk-V4OMHVJN.js";
-import "../chunk-GLOHF5CP.js";
-export {
-  alterColumnType,
-  dropColumnDefault,
-  dropColumnNotNull,
-  setColumnDefault,
-  setColumnNotNull
-};
+import { Dialect } from '../table/constants';
+
+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, dropColumnDefault, dropColumnNotNull, setColumnDefault, setColumnNotNull };

package/dist/database/column.d.ts

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

package/dist/database/column.js

@@ -1,11 +1,33 @@
-import {
-  addColumn,
-  dropColumn,
-  renameColumn
-} from "../chunk-JF7OSNH4.js";
-import "../chunk-GLOHF5CP.js";
-export {
-  addColumn,
-  dropColumn,
-  renameColumn
-};
+import { Dialect } from '../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 === 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 === 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;
+}
+
+export { addColumn, dropColumn, renameColumn };

package/dist/database/contract.d.ts

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

package/dist/database/contract.js

@@ -0,0 +1 @@
+

package/dist/database/index.d.ts

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

package/dist/database/index.js

@@ -1,19 +1,92 @@
-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
-};
+import '../table';
+import { Dialect } from '../table/constants';
+import { alterColumnType, setColumnDefault, dropColumnDefault, dropColumnNotNull } from './alter';
+import { addColumn, renameColumn, dropColumn } from './column';
+import { createTable, renameTable, dropTable } from './table';
+import { DatabasePsql, DatabaseSqlite } from './wrapper';
+
+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 === Dialect.POSTGRES ? new DatabasePsql(options.config) : new DatabaseSqlite(options.config);
+    if (options.tables) {
+      for (const tableName in options.tables) {
+        options.tables[tableName].client = this.client;
+      }
+    }
+    this.createTable = createTable.bind(this);
+    this.renameTable = renameTable.bind(this);
+    this.dropTable = dropTable.bind(this);
+    this.addColumn = addColumn.bind(this);
+    this.renameColumn = renameColumn.bind(this);
+    this.dropColumn = dropColumn.bind(this);
+    this.alterColumnType = alterColumnType.bind(
+      this
+    );
+    this.setColumnDefault = setColumnDefault.bind(
+      this
+    );
+    this.dropColumnDefault = dropColumnDefault.bind(
+      this
+    );
+    this.setColumnNotNull = setColumnDefault.bind(
+      this
+    );
+    this.dropColumnNotNull = 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);
+  }
+}
+
+export { Database };

package/dist/database/table.d.ts

@@ -1,11 +1,11 @@
-import { D as Database } from '../index-Dcm5xIpR.js';
+import { D as Database } from '../index-DFrpzXEn.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 { T as Table, D as DatabaseDefinition, a as TimestampOptions, M as MergeTimestampParanoid } from '../index-FMT0YEO7.js';
 import { Dialect } from '../table/constants.js';
+import '../query/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>;

package/dist/database/table.js

@@ -1,19 +1,37 @@
-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
-};
+import { Table } from '../table';
+
+async function createTable(tableName, columns, options) {
+  const table = Table.define({
+    name: tableName,
+    dialect: this.dialect,
+    columns,
+    ...options
+  });
+  table.client = this.client;
+  this.tables[tableName] = table;
+  if (!this?.client) {
+    throw new Error("Database not connected");
+  }
+  while (this.client.status === "connecting") {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  await table.create(this.client);
+  return this;
+}
+async function renameTable(oldName, newName) {
+  await this.client.exec(`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};`);
+    return this;
+  }
+  await this.tables[tableName].drop(this.client);
+  delete this.tables[tableName];
+  return this;
+}
+
+export { createTable, dropTable, renameTable };