@ignisia/sql 0.2.2 → 0.4.0

package/dist/esm/column/utils.js

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

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

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

package/dist/esm/database/alter.js

@@ -5,9 +5,9 @@ async function alterColumnType(tableName, columnName, newType) {
   if (this.dialect === Dialect.SQLITE) {
     throw new Error("SQLite does not support ALTER COLUMN TYPE directly.");
   }
-  await this.client.exec(
-    `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} TYPE ${newType}`
-  );
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} TYPE ${newType}`
+  });
   if (!this.tables[tableName]) return this;
   this.tables[tableName].columns[columnName].type = newType;
   return this;
@@ -16,9 +16,9 @@ async function setColumnDefault(tableName, columnName, value) {
   if (this.dialect === Dialect.SQLITE) {
     throw new Error("SQLite does not support ALTER COLUMN DEFAULT directly.");
   }
-  await this.client.exec(
-    `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET DEFAULT ${value}`
-  );
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET DEFAULT ${value}`
+  });
   if (!this.tables[tableName]) return this;
   if (
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -33,9 +33,9 @@ async function dropColumnDefault(tableName, columnName) {
   if (this.dialect === Dialect.SQLITE) {
     throw new Error("SQLite does not support DROP DEFAULT directly.");
   }
-  await this.client.exec(
-    `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP DEFAULT`
-  );
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP DEFAULT`
+  });
   if (!this.tables[tableName]) return this;
   if (
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -52,9 +52,9 @@ async function setColumnNotNull(tableName, columnName) {
       "SQLite does not support SET NOT NULL (requires table rebuild)"
     );
   }
-  await this.client.exec(
-    `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET NOT NULL`
-  );
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} SET NOT NULL`
+  });
   if (!this.tables[tableName]) return this;
   if (
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -71,9 +71,9 @@ async function dropColumnNotNull(tableName, columnName) {
       "SQLite does not support DROP NOT NULL (requires table rebuild)"
     );
   }
-  await this.client.exec(
-    `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP NOT NULL`
-  );
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} ALTER COLUMN ${columnName} DROP NOT NULL`
+  });
   if (!this.tables[tableName]) return this;
   if (
     // eslint-disable-next-line @typescript-eslint/no-explicit-any

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

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

package/dist/esm/database/column.js

@@ -2,9 +2,9 @@ import { Dialect } from '../table/constants.js';
 
 // src/database/column.ts
 async function addColumn(tableName, columnName, column) {
-  await this.client.exec(
-    `ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${column.toString()};`
-  );
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${column.toString()};`
+  });
   if (!this.tables[tableName]) return this;
   this.tables[tableName].columns[columnName] = column;
   return this;
@@ -13,9 +13,9 @@ async function renameColumn(tableName, oldName, newName) {
   if (this.dialect === Dialect.SQLITE) {
     throw new Error("SQLite does not support RENAME COLUMN natively.");
   }
-  await this.client.exec(
-    `ALTER TABLE ${tableName} RENAME COLUMN ${oldName} TO ${newName};`
-  );
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} RENAME COLUMN ${oldName} TO ${newName};`
+  });
   if (!this.tables[tableName]) return this;
   this.tables[tableName].columns[newName] = this.tables[tableName].columns[oldName];
   delete this.tables[tableName].columns[oldName];
@@ -25,7 +25,9 @@ async function dropColumn(tableName, columnName) {
   if (this.dialect === Dialect.SQLITE) {
     throw new Error("SQLite does not support DROP COLUMN natively.");
   }
-  await this.client.exec(`ALTER TABLE ${tableName} DROP COLUMN ${columnName};`);
+  await this.client.exec({
+    sql: `ALTER TABLE ${tableName} DROP COLUMN ${columnName};`
+  });
   if (!this.tables[tableName]) return this;
   delete this.tables[tableName].columns[columnName];
   return this;

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

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

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

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

package/dist/esm/database/index.js

@@ -1,9 +1,9 @@
 import '../table/index.js';
 import { Dialect } from '../table/constants.js';
-import { alterColumnType, setColumnDefault, dropColumnDefault, dropColumnNotNull } from './alter.js';
+import { alterColumnType, setColumnDefault, dropColumnDefault, setColumnNotNull, dropColumnNotNull } from './alter.js';
 import { addColumn, renameColumn, dropColumn } from './column.js';
 import { createTable, renameTable, dropTable } from './table.js';
-import { DatabasePsql, DatabaseSqlite } from './wrapper.js';
+import { DatabaseMysql, DatabasePsql, DatabaseSqlite } from './wrapper.js';
 
 // src/database/index.ts
 var Database = class _Database {
@@ -31,10 +31,11 @@ var Database = class _Database {
       dialect: options.dialect,
       config: options.config
     };
-    this.client = options.dialect === Dialect.POSTGRES ? new DatabasePsql(options.config) : new DatabaseSqlite(options.config);
+    this.client = this.createClient(options);
     if (options.tables) {
       for (const tableName in options.tables) {
         options.tables[tableName].client = this.client;
+        options.tables[tableName].setDialect(this.dialect);
       }
     }
     this.createTable = createTable.bind(this);
@@ -52,13 +53,25 @@ var Database = class _Database {
     this.dropColumnDefault = dropColumnDefault.bind(
       this
     );
-    this.setColumnNotNull = setColumnDefault.bind(
+    this.setColumnNotNull = setColumnNotNull.bind(
       this
     );
     this.dropColumnNotNull = dropColumnNotNull.bind(
       this
     );
   }
+  createClient(options) {
+    switch (options.dialect) {
+      case Dialect.SQLITE:
+        return new DatabaseSqlite(options.config);
+      case Dialect.POSTGRES:
+        return new DatabasePsql(options.config);
+      case Dialect.MYSQL:
+        return new DatabaseMysql(options.config);
+      default:
+        throw new Error(`Dialect ${options.dialect} is not supported`);
+    }
+  }
   table(tableName) {
     if (!this.tables[tableName]) {
       throw new Error(`Table ${tableName} does not exist`);

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

@@ -1,7 +1,8 @@
-import { D as Database } from '../index-DFrpzXEn.js';
+import { D as Database } from '../index-DgOs61lH.js';
 import { Column } from '../column/index.js';
-import { T as Table, D as DatabaseDefinition, a as TimestampOptions, M as MergeTimestampParanoid } from '../index-FMT0YEO7.js';
+import { T as Table, D as DatabaseDefinition, f as TimestampOptions, M as MergeTimestampParanoid } from '../index-CjurLJdK.js';
 import { Dialect } from '../table/constants.js';
+import 'bun';
 import '../query/constants.js';
 import '../column/constants.js';
 import '../column/types.js';

package/dist/esm/database/table.js

@@ -16,21 +16,29 @@ async function createTable(tableName, columns, options) {
   while (this.client.status === "connecting") {
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
-  await table.create(this.client);
+  await table.create({
+    db: this.client
+  });
   return this;
 }
 async function renameTable(oldName, newName) {
-  await this.client.exec(`ALTER TABLE ${oldName} RENAME TO ${newName};`);
+  await this.client.exec({
+    sql: `ALTER TABLE ${oldName} RENAME TO ${newName};`
+  });
   this.tables[newName] = this.tables[oldName];
   delete this.tables[oldName];
   return this;
 }
 async function dropTable(tableName) {
   if (!this.tables[tableName]) {
-    await this.client.exec(`DROP TABLE IF EXISTS ${tableName};`);
+    await this.client.exec({
+      sql: `DROP TABLE IF EXISTS ${tableName};`
+    });
     return this;
   }
-  await this.tables[tableName].drop(this.client);
+  await this.tables[tableName].drop({
+    db: this.client
+  });
   delete this.tables[tableName];
   return this;
 }

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

@@ -1,5 +1,6 @@
+import 'bun';
 import '../column/index.js';
-export { D as DatabaseDefinition, b as DatabaseDialect, g as DatabaseOptions, P as PostgresConfig, S as SqliteConfig } from '../index-FMT0YEO7.js';
+export { D as DatabaseDefinition, g as DatabaseDialect, h as DatabaseExecOptions, q as DatabaseOptions, i as MysqlConfig, P as PostgresConfig, J as SqlConfig, S as SqlConfigMapping, j as SqliteConfig } from '../index-CjurLJdK.js';
 import '../table/constants.js';
 import '../column/constants.js';
 import '../column/types.js';

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

@@ -1,36 +1,32 @@
-import { SQL } from 'bun';
-import { Database } from 'bun:sqlite';
+import { SQL, TransactionSQL } from 'bun';
 import { Dialect } from '../table/constants.js';
-import { b as DatabaseDialect, P as PostgresConfig, S as SqliteConfig } from '../index-FMT0YEO7.js';
+import { S as SqlConfigMapping, g as DatabaseDialect, h as DatabaseExecOptions, P as PostgresConfig, i as MysqlConfig, j as SqliteConfig } from '../index-CjurLJdK.js';
 import '../column/index.js';
 import '../column/constants.js';
 import '../column/types.js';
 import '../types.js';
 import '../query/constants.js';
 
-declare class DatabasePsql implements DatabaseDialect {
-    readonly dialect: typeof Dialect.POSTGRES;
-    readonly options: PostgresConfig;
+declare class BaseSql<DbDialect extends Dialect, Options extends SqlConfigMapping[DbDialect]> implements DatabaseDialect {
+    readonly dialect: Dialect;
+    readonly options: Options;
     client: SQL;
     status: 'connecting' | 'connected' | 'disconnected';
-    constructor(options: PostgresConfig);
+    constructor(dialect: Dialect, options: Options);
     connect(): Promise<this>;
     disconnect(): Promise<this>;
-    exec<T>(sql: string): Promise<T>;
-    exec<T>(sql: string, values: any[]): Promise<T>;
-    transaction<T, U extends () => Promise<T>>(fn: U): Promise<T>;
+    exec<T>(options: DatabaseExecOptions): Promise<T>;
+    transaction<T, U extends (tx: TransactionSQL) => Promise<T>>(fn: U): Promise<T>;
+    distributed<T extends string, U, V extends (tx: TransactionSQL) => Promise<U>>(name: T, fn: V): Promise<U>;
 }
-declare class DatabaseSqlite implements DatabaseDialect {
-    readonly dialect: typeof Dialect.SQLITE;
-    readonly options: SqliteConfig;
-    client: Database;
-    status: 'connecting' | 'connected' | 'disconnected';
+declare class DatabasePsql extends BaseSql<typeof Dialect.POSTGRES, PostgresConfig> {
+    constructor(options: PostgresConfig);
+}
+declare class DatabaseMysql extends BaseSql<typeof Dialect.MYSQL, MysqlConfig> {
+    constructor(options: MysqlConfig);
+}
+declare class DatabaseSqlite extends BaseSql<typeof Dialect.SQLITE, SqliteConfig> {
     constructor(options: SqliteConfig);
-    connect(): Promise<this>;
-    disconnect(): Promise<this>;
-    exec<T>(sql: string): Promise<T>;
-    exec<T>(sql: string, params: any): Promise<T>;
-    transaction<T, U extends () => Promise<T>>(fn: U): Promise<T>;
 }
 
-export { DatabasePsql, DatabaseSqlite };
+export { BaseSql, DatabaseMysql, DatabasePsql, DatabaseSqlite };

package/dist/esm/database/wrapper.js

@@ -1,19 +1,19 @@
 import { SQL } from 'bun';
-import { Database } from 'bun:sqlite';
 import { Dialect } from '../table/constants.js';
 
 // src/database/wrapper.ts
-var DatabasePsql = class {
+var BaseSql = class {
   dialect;
   options;
   client;
   status;
-  constructor(options) {
-    this.dialect = Dialect.POSTGRES;
+  constructor(dialect, options) {
+    this.dialect = dialect;
     this.options = options;
     this.status = "connecting";
     this.client = new SQL({
       ...options,
+      adapter: dialect,
       onconnect: () => {
         this.status = "connected";
       },
@@ -31,63 +31,37 @@ var DatabasePsql = class {
     await this.client.close();
     return this;
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async exec(sql, values) {
-    if (!values) {
-      return this.client.unsafe(sql);
+  async exec(options) {
+    const client = options.tx || this.client;
+    if (!client) {
+      throw new Error("Database not connected");
+    }
+    if (!options.params) {
+      return client.unsafe(options.sql);
     }
-    return this.client.unsafe(sql, values);
+    return client.unsafe(options.sql, options.params);
   }
   async transaction(fn) {
-    try {
-      await this.exec("BEGIN");
-      const result = await fn();
-      await this.exec("COMMIT");
-      return result;
-    } catch (err) {
-      await this.exec("ROLLBACK");
-      throw err;
-    }
+    return this.client.transaction(fn);
+  }
+  async distributed(name, fn) {
+    return this.client.distributed(name, fn);
   }
 };
-var DatabaseSqlite = class {
-  dialect;
-  options;
-  client;
-  status;
+var DatabasePsql = class extends BaseSql {
   constructor(options) {
-    this.dialect = Dialect.SQLITE;
-    this.options = options;
-    this.status = "connecting";
-    this.client = new Database(options.filename);
-    this.status = "connected";
-  }
-  async connect() {
-    this.client = new Database(this.options.filename);
-    this.status = "connected";
-    return this;
-  }
-  async disconnect() {
-    this.client.close();
-    this.status = "disconnected";
-    return this;
+    super(Dialect.POSTGRES, options);
   }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async exec(sql, params) {
-    const query = this.client.prepare(sql, params);
-    return query.all();
+};
+var DatabaseMysql = class extends BaseSql {
+  constructor(options) {
+    super(Dialect.MYSQL, options);
   }
-  async transaction(fn) {
-    try {
-      await this.exec("BEGIN");
-      const result = await fn();
-      await this.exec("COMMIT");
-      return result;
-    } catch (err) {
-      await this.exec("ROLLBACK");
-      throw err;
-    }
+};
+var DatabaseSqlite = class extends BaseSql {
+  constructor(options) {
+    super(Dialect.SQLITE, options);
   }
 };
 
-export { DatabasePsql, DatabaseSqlite };
+export { BaseSql, DatabaseMysql, DatabasePsql, DatabaseSqlite };