@ignisia/sql 0.2.2 → 0.4.0

package/dist/cjs/database/column.js

@@ -3,9 +3,9 @@
 var constants = require('../table/constants');
 
 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;
@@ -14,9 +14,9 @@ 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};`
-  );
+  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];
@@ -26,7 +26,9 @@ 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};`);
+  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/cjs/database/contract.d.cts

@@ -1,8 +1,9 @@
-export { C as ColumnAlterationContract, T as TableAlterationContract } from '../index---zaMa69.cjs';
+export { C as ColumnAlterationContract, T as TableAlterationContract } from '../index-CZhrzE5r.cjs';
 import '../column/index.cjs';
 import '../column/constants.cjs';
-import '../index-CwiFQh0I.cjs';
+import '../index-CHxuUiO4.cjs';
 import '../table/constants.cjs';
+import 'bun';
 import '../query/constants.cjs';
 import '../column/types.cjs';
 import '../types.cjs';

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

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

package/dist/cjs/database/index.js

@@ -32,10 +32,11 @@ class Database {
       dialect: options.dialect,
       config: options.config
     };
-    this.client = options.dialect === constants.Dialect.POSTGRES ? new wrapper.DatabasePsql(options.config) : new wrapper.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 = table.createTable.bind(this);
@@ -53,13 +54,25 @@ class Database {
     this.dropColumnDefault = alter.dropColumnDefault.bind(
       this
     );
-    this.setColumnNotNull = alter.setColumnDefault.bind(
+    this.setColumnNotNull = alter.setColumnNotNull.bind(
       this
     );
     this.dropColumnNotNull = alter.dropColumnNotNull.bind(
       this
     );
   }
+  createClient(options) {
+    switch (options.dialect) {
+      case constants.Dialect.SQLITE:
+        return new wrapper.DatabaseSqlite(options.config);
+      case constants.Dialect.POSTGRES:
+        return new wrapper.DatabasePsql(options.config);
+      case constants.Dialect.MYSQL:
+        return new wrapper.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/cjs/database/table.d.cts

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

package/dist/cjs/database/table.js

@@ -17,21 +17,29 @@ async function createTable(tableName, columns, options) {
   while (this.client.status === "connecting") {
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
-  await table$1.create(this.client);
+  await table$1.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/cjs/database/types.d.cts

@@ -1,5 +1,6 @@
+import 'bun';
 import '../column/index.cjs';
-export { D as DatabaseDefinition, b as DatabaseDialect, g as DatabaseOptions, P as PostgresConfig, S as SqliteConfig } from '../index-CwiFQh0I.cjs';
+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-CHxuUiO4.cjs';
 import '../table/constants.cjs';
 import '../column/constants.cjs';
 import '../column/types.cjs';

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

@@ -1,36 +1,32 @@
-import { SQL } from 'bun';
-import { Database } from 'bun:sqlite';
+import { SQL, TransactionSQL } from 'bun';
 import { Dialect } from '../table/constants.cjs';
-import { b as DatabaseDialect, P as PostgresConfig, S as SqliteConfig } from '../index-CwiFQh0I.cjs';
+import { S as SqlConfigMapping, g as DatabaseDialect, h as DatabaseExecOptions, P as PostgresConfig, i as MysqlConfig, j as SqliteConfig } from '../index-CHxuUiO4.cjs';
 import '../column/index.cjs';
 import '../column/constants.cjs';
 import '../column/types.cjs';
 import '../types.cjs';
 import '../query/constants.cjs';
 
-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/cjs/database/wrapper.js

@@ -1,20 +1,20 @@
 'use strict';
 
 var bun = require('bun');
-var bun_sqlite = require('bun:sqlite');
 var constants = require('../table/constants');
 
-class DatabasePsql {
+class BaseSql {
   dialect;
   options;
   client;
   status;
-  constructor(options) {
-    this.dialect = constants.Dialect.POSTGRES;
+  constructor(dialect, options) {
+    this.dialect = dialect;
     this.options = options;
     this.status = "connecting";
     this.client = new bun.SQL({
       ...options,
+      adapter: dialect,
       onconnect: () => {
         this.status = "connected";
       },
@@ -32,64 +32,40 @@ class DatabasePsql {
     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);
   }
 }
-class DatabaseSqlite {
-  dialect;
-  options;
-  client;
-  status;
+class DatabasePsql extends BaseSql {
   constructor(options) {
-    this.dialect = constants.Dialect.SQLITE;
-    this.options = options;
-    this.status = "connecting";
-    this.client = new bun_sqlite.Database(options.filename);
-    this.status = "connected";
-  }
-  async connect() {
-    this.client = new bun_sqlite.Database(this.options.filename);
-    this.status = "connected";
-    return this;
-  }
-  async disconnect() {
-    this.client.close();
-    this.status = "disconnected";
-    return this;
+    super(constants.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();
+}
+class DatabaseMysql extends BaseSql {
+  constructor(options) {
+    super(constants.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;
-    }
+}
+class DatabaseSqlite extends BaseSql {
+  constructor(options) {
+    super(constants.Dialect.SQLITE, options);
   }
 }
 
+exports.BaseSql = BaseSql;
+exports.DatabaseMysql = DatabaseMysql;
 exports.DatabasePsql = DatabasePsql;
 exports.DatabaseSqlite = DatabaseSqlite;