@ignisia/sql 0.4.0 → 0.4.2

package/dist/cjs/query/join.js

@@ -1,10 +1,16 @@
 'use strict';
 
 var _ = require('.');
+var constants = require('./constants');
 
 function addNoOnJoin(query, joinType, joinTable, alias) {
   if (!query.definition.joins) query.definition.joins = [];
-  query.definition.joins.push(`${joinType} JOIN ${joinTable.name} AS ${alias}`);
+  query.definition.joins.push({
+    type: constants.AstType.JOIN,
+    alias,
+    join: joinType,
+    table: joinTable
+  });
   if (!query.definition.joinedTables) {
     query.definition.joinedTables = {};
   }
@@ -16,21 +22,23 @@ function prepareJoin(query, joinType, joinTable, alias) {
     on(callback) {
       const sub = callback(new _.QueryBuilder(query.table));
       const subDef = sub.definition;
-      if (!subDef.where?.length) {
+      if (!subDef.where) {
         return query;
       }
-      const grouped = `(${subDef.where.join(" ")})`;
-      if (!query.definition.joins) query.definition.joins = [];
-      query.definition.joins.push(
-        `${joinType} JOIN ${joinTable.name} AS ${alias} ON ${grouped}`
-      );
+      if (!query.definition.joins) {
+        query.definition.joins = [];
+      }
+      const on = subDef.where;
+      query.definition.joins.push({
+        type: constants.AstType.JOIN,
+        alias,
+        join: joinType,
+        table: joinTable,
+        on
+      });
       if (subDef.joins?.length) {
         query.definition.joins.push(...subDef.joins);
       }
-      if (subDef.params?.length) {
-        if (!query.definition.params) query.definition.params = [];
-        query.definition.params.push(...subDef.params);
-      }
       if (!query.definition.joinedTables) {
         query.definition.joinedTables = {};
       }

package/dist/cjs/query/sql.d.cts

@@ -1,5 +1,5 @@
 import { TransactionSQL } from 'bun';
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, k as StrictColumnSelector, l as QueryBuilder, E as ExplainOptions } from '../index-CHxuUiO4.cjs';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, h as StrictColumnSelector, i as QueryBuilder, E as ExplainOptions } from '../index-CY-nPZED.cjs';
 import { Column } from '../column/index.cjs';
 import { Dialect } from '../table/constants.cjs';
 import '../types.cjs';
@@ -10,7 +10,7 @@ import '../column/types.cjs';
 declare function buildQuery(query: string): string;
 declare function toQuery<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>(this: Query, dialect?: Dialect | null): {
     query: string;
-    params: unknown[] | null | undefined;
+    params: unknown[];
 };
 declare function toString<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>(this: Query): string;
 declare function toDebugString<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>(this: Query): string;

package/dist/cjs/query/sql.js

@@ -2,6 +2,7 @@
 
 var constants$1 = require('../table/constants');
 var builder = require('./builder');
+var compiler = require('./compiler');
 var constants = require('./constants');
 var explain$1 = require('./explain');
 var utilities = require('./utilities');
@@ -13,17 +14,18 @@ function buildQuery(query) {
     return `$${index}`;
   });
 }
-function toQuery(dialect) {
+function toQuery(dialect = this.table.dialect) {
+  const params = [];
   const parts = [];
   switch (this.definition.queryType) {
     case constants.QueryType.SELECT:
       parts.push(builder.buildSelectQuery(this));
       break;
     case constants.QueryType.INSERT:
-      parts.push(builder.buildInsertQuery(this));
+      parts.push(builder.buildInsertQuery(this, params));
       break;
     case constants.QueryType.UPDATE:
-      parts.push(builder.buildUpdateQuery(this));
+      parts.push(builder.buildUpdateQuery(this, params));
       break;
     case constants.QueryType.DELETE:
       parts.push(builder.buildDeleteQuery(this));
@@ -32,33 +34,39 @@ function toQuery(dialect) {
       throw new Error("No query type defined");
   }
   if (this.definition?.joins?.length) {
-    parts.push(this.definition.joins.join(" "));
+    const joinParts = this.definition.joins.map(
+      (join) => compiler.compileJoin(dialect, join, params)
+    );
+    parts.push(...joinParts);
   }
-  const whereConditions = utilities.getWhereConditions(this);
-  if (whereConditions.length) {
-    parts.push(`WHERE ${whereConditions.join(" ")}`);
+  if (this.definition.where) {
+    const whereConditions = compiler.compileAst(dialect, this.definition.where, params);
+    parts.push(`WHERE ${whereConditions}`);
   }
   const groupByConditions = utilities.getGroupByConditions(this);
   if (groupByConditions.length) {
     parts.push(`GROUP BY ${groupByConditions.join(", ")}`);
   }
-  if (this.definition?.having?.length) {
-    parts.push(`HAVING ${this.definition.having.join(" ")}`);
+  if (this.definition?.having) {
+    const havingConditions = compiler.compileAst(
+      dialect,
+      this.definition.having,
+      params
+    );
+    parts.push(`HAVING ${havingConditions}`);
   }
   if (this.definition?.orderBy?.length) {
     parts.push(
       `ORDER BY ${this.definition.orderBy.map((order) => `${order.column} ${order.direction}`).join(", ")}`
     );
   }
-  if (this.definition?.limit !== null) {
+  if (this.definition?.limit != null) {
     parts.push("LIMIT ?");
-    if (!this.definition.params) this.definition.params = [];
-    this.definition.params.push(this.definition.limit);
+    params.push(this.definition.limit);
   }
-  if (this.definition?.offset !== null) {
+  if (this.definition?.offset != null) {
     parts.push("OFFSET ?");
-    if (!this.definition.params) this.definition.params = [];
-    this.definition.params.push(this.definition.offset);
+    params.push(this.definition.offset);
   }
   if (this.definition.queryType === constants.QueryType.UPDATE || this.definition.queryType === constants.QueryType.DELETE) {
     if (dialect !== constants$1.Dialect.MYSQL) {
@@ -66,7 +74,7 @@ function toQuery(dialect) {
     }
   }
   const sql = buildQuery(parts.join(" "));
-  return { query: `${sql};`, params: this.definition.params };
+  return { query: `${sql};`, params };
 }
 function toString() {
   return this.toQuery().query;
@@ -122,15 +130,24 @@ async function exec(tx) {
       });
     }
   }
-  let result = await client.exec({
+  let result = [];
+  let mySqlResult = [];
+  if (isMySQL && isDelete) {
+    const query2 = this.clone().select(`${this.table.name}.*`);
+    mySqlResult = await client.exec({
+      sql: query2.toQuery().query,
+      params,
+      tx
+    });
+  }
+  result = await client.exec({
     sql: query,
     params,
     tx
   });
-  if (isMySQL && isReturning) {
-    const query2 = this.clone();
-    query2.definition.queryType = constants.QueryType.SELECT;
-    result = await client.exec({
+  if (isMySQL && isUpdate) {
+    const query2 = this.clone().select(`${this.table.name}.*`);
+    mySqlResult = await client.exec({
       sql: query2.toQuery().query,
       params,
       tx
@@ -146,7 +163,7 @@ async function exec(tx) {
       });
     }
   }
-  return result.map(
+  return (isMySQL && isReturning ? mySqlResult : result).map(
     (r) => utilities.parseAliasedRow({
       row: r,
       selects: this.definition.select ?? [],

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

@@ -1,7 +1,7 @@
 import 'bun';
 import '../column/index.cjs';
 import '../column/constants.cjs';
-export { u as AcceptedInsertValues, t as AcceptedOrderBy, v as AcceptedUpdateValues, w as AggregateColumn, A as AliasedColumn, C as ColumnSelector, E as ExplainOptions, Q as QueryDefinition, p as QueryHooks, y as QueryOutput, s as QueryRunHooks, z as QueryRunHooksOptions, R as RawColumn, x as SelectQueryOutput, m as SelectableColumn, k as StrictColumnSelector, W as WhereValue } from '../index-CHxuUiO4.cjs';
+export { r as AcceptedInsertValues, q as AcceptedOrderBy, s as AcceptedUpdateValues, t as AggregateColumn, A as AliasedColumn, C as ColumnSelector, E as ExplainOptions, Q as QueryDefinition, n as QueryHooks, v as QueryOutput, p as QueryRunHooks, w as QueryRunHooksOptions, R as RawColumn, u as SelectQueryOutput, j as SelectableColumn, h as StrictColumnSelector, W as WhereValue } from '../index-CY-nPZED.cjs';
 import '../types.cjs';
 import './constants.cjs';
 import '../table/constants.cjs';

package/dist/cjs/query/utilities.d.cts

@@ -1,17 +1,16 @@
-import { T as Table, W as WhereValue, Q as QueryDefinition, C as ColumnSelector, k as StrictColumnSelector, l as QueryBuilder, A as AliasedColumn, m as SelectableColumn } from '../index-CHxuUiO4.cjs';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, h as StrictColumnSelector, i as QueryBuilder, A as AliasedColumn, j as SelectableColumn } from '../index-CY-nPZED.cjs';
 import { Column } from '../column/index.cjs';
-import { Dialect } from '../table/constants.cjs';
-import { AcceptedOperator } from './constants.cjs';
 import 'bun';
 import '../types.cjs';
+import './constants.cjs';
 import '../column/constants.cjs';
+import '../table/constants.cjs';
 import '../column/types.cjs';
 
 declare function getTableColumnNames<ColName extends string, BaseAlias extends string, BaseTable extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>>(column: ColName, baseAlias: BaseAlias, baseTable: BaseTable, joinedTables: JoinedTables): {
     from: string;
     columns: string[];
 };
-declare function getCondition<DbDialect extends Dialect, ColName extends string, Operator extends AcceptedOperator, Value extends WhereValue<Column>[Operator]>(dialect: DbDialect, column: ColName, operator: Operator, value: Value): string;
 declare function getTimestamp<TableRef extends Table<string, Record<string, Column>>>(table: TableRef): {
     isWithTimestamp: boolean;
     timestamp: Date;
@@ -25,7 +24,6 @@ declare function getParanoid<TableRef extends Table<string, Record<string, Colum
     timestamp: Date;
     deletedAt: string;
 };
-declare function getWhereConditions<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>(q: Query): string[];
 declare function getGroupByConditions<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>(q: Query): (string | AliasedColumn<ColumnSelector<Alias, TableRef, JoinedTables>, string>)[];
 declare function getTableSelectName<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables>, Query extends QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>(q: Query): string;
 declare function parseAliasedRow({ row, selects, root, }: {
@@ -35,4 +33,4 @@ declare function parseAliasedRow({ row, selects, root, }: {
 }): Record<string, any>;
 declare function sanitizeParams(params: unknown[]): (string | number | bigint | boolean | null)[];
 
-export { getCondition, getGroupByConditions, getParanoid, getTableColumnNames, getTableSelectName, getTimestamp, getWhereConditions, parseAliasedRow, sanitizeParams };
+export { getGroupByConditions, getParanoid, getTableColumnNames, getTableSelectName, getTimestamp, parseAliasedRow, sanitizeParams };

package/dist/cjs/query/utilities.js

@@ -1,7 +1,6 @@
 'use strict';
 
 require('.');
-var constants$1 = require('../table/constants');
 var utilities = require('../utilities');
 var constants = require('./constants');
 
@@ -15,102 +14,6 @@ function getTableColumnNames(column, baseAlias, baseTable, joinedTables) {
     columns
   };
 }
-function getCondition(dialect, column, operator, value) {
-  switch (operator) {
-    case constants.AcceptedOperator.EQ:
-      return `${column} = ?`;
-    case constants.AcceptedOperator.NE:
-      return `${column} != ?`;
-    case constants.AcceptedOperator.GT:
-      return `${column} > ?`;
-    case constants.AcceptedOperator.LT:
-      return `${column} < ?`;
-    case constants.AcceptedOperator.GTE:
-      return `${column} >= ?`;
-    case constants.AcceptedOperator.LTE:
-      return `${column} <= ?`;
-    case constants.AcceptedOperator.IN:
-      return `${column} IN (${value.map(() => "?").join(", ")})`;
-    case constants.AcceptedOperator.NOT_IN:
-      return `${column} NOT IN (${value.map(() => "?").join(", ")})`;
-    case constants.AcceptedOperator.LIKE:
-      return `${column} LIKE ?`;
-    case constants.AcceptedOperator.NOT_LIKE:
-      return `${column} NOT LIKE ?`;
-    case constants.AcceptedOperator.ILIKE:
-      if (dialect === constants$1.Dialect.POSTGRES) {
-        return `${column} ILIKE ?`;
-      }
-      return `LOWER(${column}) LIKE LOWER(?)`;
-    case constants.AcceptedOperator.NOT_ILIKE:
-      if (dialect === constants$1.Dialect.POSTGRES) {
-        return `${column} NOT ILIKE ?`;
-      }
-      return `LOWER(${column}) NOT LIKE LOWER(?)`;
-    case constants.AcceptedOperator.IS_NULL:
-      return `${column} IS NULL`;
-    case constants.AcceptedOperator.IS_NOT_NULL:
-      return `${column} IS NOT NULL`;
-    case constants.AcceptedOperator.BETWEEN:
-      return `${column} BETWEEN ? AND ?`;
-    case constants.AcceptedOperator.NOT_BETWEEN:
-      return `${column} NOT BETWEEN ? AND ?`;
-    case constants.AcceptedOperator.STARTS_WITH:
-      return `${column} LIKE ?`;
-    case constants.AcceptedOperator.ENDS_WITH:
-      return `${column} LIKE ?`;
-    case constants.AcceptedOperator.REG_EXP: {
-      switch (dialect) {
-        case constants$1.Dialect.POSTGRES:
-          return `${column} ~ ?`;
-        case constants$1.Dialect.MYSQL:
-          return `${column} REGEXP ?`;
-        case constants$1.Dialect.SQLITE:
-          return `${column} GLOB ?`;
-        default:
-          throw new Error("Operator not supported");
-      }
-    }
-    case constants.AcceptedOperator.NOT_REG_EXP: {
-      switch (dialect) {
-        case constants$1.Dialect.POSTGRES:
-          return `${column} !~ ?`;
-        case constants$1.Dialect.MYSQL:
-          return `${column} NOT REGEXP ?`;
-        case constants$1.Dialect.SQLITE:
-          return `${column} NOT GLOB ?`;
-        default:
-          throw new Error("Operator not supported");
-      }
-    }
-    case constants.AcceptedOperator.RLIKE: {
-      switch (dialect) {
-        case constants$1.Dialect.POSTGRES:
-          return `${column} ~* ?`;
-        case constants$1.Dialect.MYSQL:
-          return `${column} RLIKE ?`;
-        case constants$1.Dialect.SQLITE:
-          return `${column} GLOB ?`;
-        default:
-          throw new Error("Operator not supported");
-      }
-    }
-    case constants.AcceptedOperator.NOT_RLIKE: {
-      switch (dialect) {
-        case constants$1.Dialect.POSTGRES:
-          return `${column} !~* ?`;
-        case constants$1.Dialect.MYSQL:
-          return `${column} NOT RLIKE ?`;
-        case constants$1.Dialect.SQLITE:
-          return `${column} NOT GLOB ?`;
-        default:
-          throw new Error("Operator not supported");
-      }
-    }
-    default:
-      throw new Error("Invalid operator");
-  }
-}
 function getTimestamp(table) {
   const isWithTimestamp = !!table.timestamp;
   const timestamp = /* @__PURE__ */ new Date();
@@ -157,23 +60,6 @@ function getParanoid(table) {
     deletedAt
   };
 }
-function getWhereConditions(q) {
-  if (q.definition.queryType === constants.QueryType.INSERT) return [];
-  const conditions = [];
-  const base = q.definition.baseAlias ?? q.table.name;
-  const { isWithParanoid, deletedAt } = getParanoid(q.table);
-  const withDeleted = !!q.definition.withDeleted;
-  const isHasConditions = !!q.definition.where?.length;
-  if (!withDeleted && isWithParanoid) {
-    const suffix = isHasConditions ? " AND" : "";
-    const column = `${base}.${utilities.quoteIdentifier(deletedAt)}`;
-    conditions.unshift(`${column} IS NULL${suffix}`);
-  }
-  if (q.definition.where?.length) {
-    conditions.push(...q.definition.where);
-  }
-  return conditions;
-}
 function getGroupByConditions(q) {
   if (q.definition.queryType !== constants.QueryType.SELECT) return [];
   if (q.definition.groupBy?.length) return q.definition.groupBy;
@@ -254,12 +140,10 @@ function sanitizeParams(params) {
   });
 }
 
-exports.getCondition = getCondition;
 exports.getGroupByConditions = getGroupByConditions;
 exports.getParanoid = getParanoid;
 exports.getTableColumnNames = getTableColumnNames;
 exports.getTableSelectName = getTableSelectName;
 exports.getTimestamp = getTimestamp;
-exports.getWhereConditions = getWhereConditions;
 exports.parseAliasedRow = parseAliasedRow;
 exports.sanitizeParams = sanitizeParams;

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

@@ -1,4 +1,4 @@
-export { T as Table } from '../index-CHxuUiO4.cjs';
+export { T as Table } from '../index-CY-nPZED.cjs';
 import '../column/index.cjs';
 import './constants.cjs';
 import 'bun';

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

@@ -1,5 +1,5 @@
 import 'bun';
-export { X as ExecOptions, M as MergeTimestampParanoid, U as TableOptions, V as TableOutput, f as TimestampOptions } from '../index-CHxuUiO4.cjs';
+export { K as ExecOptions, M as MergeTimestampParanoid, H as TableOptions, I as TableOutput, c as TimestampOptions } from '../index-CY-nPZED.cjs';
 import '../column/index.cjs';
 import './constants.cjs';
 import '../types.cjs';

package/dist/cjs/table/utilities.d.cts

@@ -1,7 +1,7 @@
 import '../column/constants.cjs';
 import '../column/index.cjs';
 import './constants.cjs';
-export { K as createdAt, O as defineColumns, N as deletedAt, L as updatedAt } from '../index-CHxuUiO4.cjs';
+export { y as createdAt, F as defineColumns, B as deletedAt, z as updatedAt } from '../index-CY-nPZED.cjs';
 import '../column/types.cjs';
 import 'bun';
 import '../types.cjs';

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

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

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

@@ -1,6 +1,6 @@
-import { D as Database } from '../index-DgOs61lH.js';
+import { D as Database } from '../index-BWg1JZRt.js';
 import { Column } from '../column/index.js';
-import { T as Table, D as DatabaseDefinition } from '../index-CjurLJdK.js';
+import { T as Table, D as DatabaseDefinition } from '../index-CsVPGz2o.js';
 import { Dialect } from '../table/constants.js';
 import 'bun';
 import '../query/constants.js';

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

@@ -1,7 +1,7 @@
-export { C as ColumnAlterationContract, T as TableAlterationContract } from '../index-DgOs61lH.js';
+export { C as ColumnAlterationContract, T as TableAlterationContract } from '../index-BWg1JZRt.js';
 import '../column/index.js';
 import '../column/constants.js';
-import '../index-CjurLJdK.js';
+import '../index-CsVPGz2o.js';
 import '../table/constants.js';
 import 'bun';
 import '../query/constants.js';

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

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

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

@@ -1,6 +1,6 @@
-import { D as Database } from '../index-DgOs61lH.js';
+import { D as Database } from '../index-BWg1JZRt.js';
 import { Column } from '../column/index.js';
-import { T as Table, D as DatabaseDefinition, f as TimestampOptions, M as MergeTimestampParanoid } from '../index-CjurLJdK.js';
+import { T as Table, D as DatabaseDefinition, h as TimestampOptions, M as MergeTimestampParanoid } from '../index-CsVPGz2o.js';
 import { Dialect } from '../table/constants.js';
 import 'bun';
 import '../query/constants.js';

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

@@ -1,6 +1,6 @@
 import 'bun';
 import '../column/index.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';
+export { D as DatabaseDefinition, j as DatabaseDialect, k as DatabaseExecOptions, o as DatabaseOptions, l as MysqlConfig, P as PostgresConfig, x as SqlConfig, i as SqlConfigMapping, m as SqliteConfig } from '../index-CsVPGz2o.js';
 import '../table/constants.js';
 import '../column/constants.js';
 import '../column/types.js';

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

@@ -1,6 +1,6 @@
 import { SQL, TransactionSQL } from 'bun';
 import { Dialect } from '../table/constants.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 { i as SqlConfigMapping, j as DatabaseDialect, k as DatabaseExecOptions, P as PostgresConfig, l as MysqlConfig, m as SqliteConfig } from '../index-CsVPGz2o.js';
 import '../column/index.js';
 import '../column/constants.js';
 import '../column/types.js';

package/dist/esm/{index-DgOs61lH.d.ts → index-BWg1JZRt.d.ts}

@@ -1,6 +1,6 @@
 import { TransactionSQL } from 'bun';
 import { Column } from './column/index.js';
-import { T as Table, D as DatabaseDefinition, f as TimestampOptions, M as MergeTimestampParanoid, p as QueryHooks, g as DatabaseDialect, q as DatabaseOptions, l as QueryBuilder, s as QueryRunHooks } from './index-CjurLJdK.js';
+import { T as Table, D as DatabaseDefinition, h as TimestampOptions, M as MergeTimestampParanoid, n as QueryHooks, j as DatabaseDialect, o as DatabaseOptions, c as QueryBuilder, p as QueryRunHooks } from './index-CsVPGz2o.js';
 import { QueryHooksType } from './query/constants.js';
 import { Dialect } from './table/constants.js';
 import { AcceptedColumnTypes } from './column/constants.js';