@ignisia/sql 0.3.0 → 0.4.1

package/dist/esm/query/helper.js

@@ -1,5 +1,5 @@
 import { QueryBuilder } from './index.js';
-import { deepClone } from '../utilities.js';
+import { cloneDefinition } from '../utilities.js';
 
 // src/query/helper.ts
 function alias(alias2) {
@@ -8,12 +8,9 @@ function alias(alias2) {
 }
 function clone() {
   const query = new QueryBuilder(this.table);
-  Object.assign(query.definition, deepClone(this.definition));
+  Object.assign(query.definition, cloneDefinition(this.definition));
   return query;
 }
-function rawCol(column) {
-  return column;
-}
 function col(column, alias2) {
   return {
     column,
@@ -28,4 +25,4 @@ function aggregateCol(fn, column, alias2) {
   };
 }
 
-export { aggregateCol, alias, clone, col, rawCol };
+export { aggregateCol, alias, clone, col };

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

@@ -1,8 +1,8 @@
+export { i as QueryBuilder } from '../index-CARBkj9h.js';
 import '../column/index.js';
-export { f as QueryBuilder } from '../index-BdpoD4zk.js';
+import '../types.js';
 import './constants.js';
-import '../table/constants.js';
+import 'bun';
 import '../column/constants.js';
+import '../table/constants.js';
 import '../column/types.js';
-import '../types.js';
-import 'bun';

package/dist/esm/query/index.js

@@ -1,9 +1,9 @@
 import { quoteIdentifier } from '../utilities.js';
-import { rawWhere, rawHaving, rawOr, where, having, or } from './condition.js';
+import { where, having, or, whereGroup, orGroup, orNotGroup, whereNotGroup, orNot, havingNot, whereNot } from './condition/index.js';
 import { AcceptedJoin, QueryType } from './constants.js';
 import { alias, clone, aggregateCol, col } from './helper.js';
-import { addJoin } from './join.js';
-import { toQuery, toString, exec } from './sql.js';
+import { prepareJoin, addNoOnJoin } from './join.js';
+import { toQuery, toString, toDebugString, explain, exec } from './sql.js';
 import { getTimestamp, getParanoid } from './utilities.js';
 
 // src/query/index.ts
@@ -16,90 +16,62 @@ var QueryBuilder = class {
   clone;
   toQuery;
   toString;
+  toDebugString;
+  explain;
   exec;
-  rawWhere;
-  rawAnd;
-  rawOr;
-  rawHaving;
   where;
   and;
   or;
   having;
+  whereGroup;
+  orGroup;
+  not;
   constructor(table) {
     this.hooks = {};
     this.table = table;
     this.definition = {
-      queryType: null,
-      select: null,
-      having: null,
-      where: null,
-      params: null,
-      limit: null,
-      offset: null,
-      groupBy: null,
-      insertValues: null,
-      updateValues: null,
-      orderBy: null,
-      aggregates: null,
-      joins: null,
-      distinct: null,
-      baseAlias: table.name,
-      joinedTables: null,
-      withDeleted: null
+      baseAlias: table.name
     };
     this.alias = alias.bind(this);
     this.clone = clone.bind(this);
     this.toQuery = toQuery.bind(this);
     this.toString = toString.bind(this);
+    this.toDebugString = toDebugString.bind(this);
+    this.explain = explain.bind(this);
     this.exec = exec.bind(this);
-    this.rawWhere = rawWhere.bind(this);
-    this.rawHaving = rawHaving.bind(this);
-    this.rawAnd = this.rawWhere;
-    this.rawOr = rawOr.bind(this);
     this.where = where.bind(this);
     this.having = having.bind(this);
     this.and = this.where;
     this.or = or.bind(this);
+    this.whereGroup = whereGroup.bind(this);
+    this.orGroup = orGroup.bind(this);
+    this.not = {
+      where: whereNot.bind(this),
+      having: havingNot.bind(this),
+      or: orNot.bind(this),
+      whereGroup: whereNotGroup.bind(
+        this
+      ),
+      orGroup: orNotGroup.bind(this)
+    };
   }
-  leftJoin(joinTable, alias2, baseColumn, joinColumn) {
-    return addJoin(
-      this,
-      AcceptedJoin.LEFT,
-      alias2,
-      joinTable,
-      baseColumn,
-      joinColumn
-    );
+  leftJoin(joinTable, alias2) {
+    return prepareJoin(this, AcceptedJoin.LEFT, joinTable, alias2);
   }
-  rightJoin(joinTable, alias2, baseColumn, joinColumn) {
-    return addJoin(
-      this,
-      AcceptedJoin.RIGHT,
-      alias2,
-      joinTable,
-      baseColumn,
-      joinColumn
-    );
+  rightJoin(joinTable, alias2) {
+    return prepareJoin(this, AcceptedJoin.RIGHT, joinTable, alias2);
   }
-  innerJoin(joinTable, alias2, baseColumn, joinColumn) {
-    return addJoin(
-      this,
-      AcceptedJoin.INNER,
-      alias2,
-      joinTable,
-      baseColumn,
-      joinColumn
-    );
+  innerJoin(joinTable, alias2) {
+    return prepareJoin(this, AcceptedJoin.INNER, joinTable, alias2);
   }
-  naturalJoin(joinTable, alias2, baseColumn, joinColumn) {
-    return addJoin(
-      this,
-      AcceptedJoin.NATURAL,
-      alias2,
-      joinTable,
-      baseColumn,
-      joinColumn
-    );
+  fullJoin(joinTable, alias2) {
+    return prepareJoin(this, AcceptedJoin.FULL, joinTable, alias2);
+  }
+  crossJoin(joinTable, alias2) {
+    return addNoOnJoin(this, AcceptedJoin.CROSS, joinTable, alias2);
+  }
+  naturalJoin(joinTable, alias2) {
+    return addNoOnJoin(this, AcceptedJoin.NATURAL, joinTable, alias2);
   }
   distinct() {
     this.definition.distinct = true;
@@ -161,17 +133,19 @@ var QueryBuilder = class {
       updatedAt,
       timestamp
     } = getTimestamp(this.table);
-    if (isWithTimestamp) {
-      values = values.map((row) => ({
-        ...row,
-        ...isHasCreatedAt && {
-          [createdAt]: row[createdAt] ?? timestamp
-        },
-        ...isHasUpdatedAt && {
-          [updatedAt]: row[updatedAt] ?? timestamp
-        }
-      }));
-    }
+    values = values.map((row) => {
+      const fields = {};
+      for (const key in this.table.columns) {
+        fields[key] = row[key] ?? null;
+      }
+      if (isWithTimestamp && isHasCreatedAt) {
+        fields[createdAt] = row[createdAt] ?? timestamp;
+      }
+      if (isWithTimestamp && isHasUpdatedAt) {
+        fields[updatedAt] = row[updatedAt] ?? timestamp;
+      }
+      return fields;
+    });
     this.definition.insertValues = values;
     return this;
   }
@@ -197,6 +171,17 @@ var QueryBuilder = class {
     this.definition.queryType = QueryType.DELETE;
     return this;
   }
+  paginate(page, size) {
+    if (page < 1) {
+      throw new Error("Page number must be at least 1");
+    }
+    if (size < 1) {
+      throw new Error("Page size must be at least 1");
+    }
+    this.definition.limit = size;
+    this.definition.offset = (page - 1) * size;
+    return this;
+  }
   infer() {
     return null;
   }

package/dist/esm/query/join.d.ts

@@ -1,17 +1,29 @@
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, e as StrictColumnSelector, f as QueryBuilder } from '../index-BdpoD4zk.js';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, h as StrictColumnSelector, i as QueryBuilder, J as JoinNode, k as QueryTransformerContract, l as QueryConditionContract } from '../index-CARBkj9h.js';
 import { Column } from '../column/index.js';
 import { AcceptedJoin } from './constants.js';
-import '../column/constants.js';
-import '../types.js';
 import 'bun';
+import '../types.js';
+import '../column/constants.js';
 import '../table/constants.js';
 import '../column/types.js';
 
-declare function addJoin<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>, JoinType extends AcceptedJoin, JoinTable extends Table<string, Record<string, Column>>, JoinAlias extends string, BaseColName extends `${Alias}."${keyof TableRef['columns'] & string}"`, JoinColName extends `${JoinAlias}."${keyof JoinTable['columns'] & string}"`, FinalJoinedTables extends JoinedTables & {
+declare function addNoOnJoin<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>, JoinType extends AcceptedJoin, JoinTable extends Table<string, Record<string, Column>>, JoinAlias extends string, FinalJoinedTables extends JoinedTables & {
     [K in JoinAlias]: JoinTable;
-}>(query: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, joinType: JoinType, alias: JoinAlias, joinTable: JoinTable, baseColumn: BaseColName, joinColumn: JoinColName): QueryBuilder<Alias, TableRef, FinalJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
-    joins: string[];
+}>(query: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, joinType: JoinType, joinTable: JoinTable, alias: JoinAlias): QueryBuilder<Alias, TableRef, FinalJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
+    joins: JoinNode[];
     joinedTables: FinalJoinedTables;
 }>;
+declare function prepareJoin<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>, JoinType extends AcceptedJoin, JoinTable extends Table<string, Record<string, Column>>, JoinAlias extends string>(query: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, joinType: JoinType, joinTable: JoinTable, alias: JoinAlias): {
+    on<FinalJoinedTables extends JoinedTables & { [K in JoinAlias]: JoinTable; }, ReturnedJoinedTables extends FinalJoinedTables = FinalJoinedTables>(callback: (q: QueryBuilder<Alias, TableRef, FinalJoinedTables>) => QueryBuilder<Alias, TableRef, ReturnedJoinedTables>): QueryBuilder<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
+        joins: JoinNode[];
+        joinedTables: ReturnedJoinedTables;
+    }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>, QueryTransformerContract<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
+        joins: JoinNode[];
+        joinedTables: ReturnedJoinedTables;
+    }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>, QueryConditionContract<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
+        joins: JoinNode[];
+        joinedTables: ReturnedJoinedTables;
+    }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>>;
+};
 
-export { addJoin };
+export { addNoOnJoin, prepareJoin };

package/dist/esm/query/join.js

@@ -1,17 +1,53 @@
+import { QueryBuilder } from './index.js';
+import { AstType } from './constants.js';
+
 // src/query/join.ts
-function addJoin(query, joinType, alias, joinTable, baseColumn, joinColumn) {
+function addNoOnJoin(query, joinType, joinTable, alias) {
   if (!query.definition.joins) query.definition.joins = [];
-  query.definition.joins.push(
-    `${joinType} JOIN ${joinTable.name} AS ${alias} ON ${baseColumn} = ${joinColumn}`
-  );
+  query.definition.joins.push({
+    type: AstType.JOIN,
+    alias,
+    join: joinType,
+    table: joinTable
+  });
   if (!query.definition.joinedTables) {
     query.definition.joinedTables = {};
   }
-  query.definition.joinedTables = {
-    ...query.definition.joinedTables,
-    [alias]: joinTable
-  };
+  query.definition.joinedTables[alias] = joinTable;
   return query;
 }
+function prepareJoin(query, joinType, joinTable, alias) {
+  return {
+    on(callback) {
+      const sub = callback(new QueryBuilder(query.table));
+      const subDef = sub.definition;
+      if (!subDef.where) {
+        return query;
+      }
+      if (!query.definition.joins) {
+        query.definition.joins = [];
+      }
+      const on = subDef.where;
+      query.definition.joins.push({
+        type: AstType.JOIN,
+        alias,
+        join: joinType,
+        table: joinTable,
+        on
+      });
+      if (subDef.joins?.length) {
+        query.definition.joins.push(...subDef.joins);
+      }
+      if (!query.definition.joinedTables) {
+        query.definition.joinedTables = {};
+      }
+      query.definition.joinedTables[alias] = joinTable;
+      if (subDef.joinedTables) {
+        Object.assign(query.definition.joinedTables, subDef.joinedTables);
+      }
+      return query;
+    }
+  };
+}
 
-export { addJoin };
+export { addNoOnJoin, prepareJoin };

package/dist/esm/query/sql.d.ts

@@ -1,18 +1,20 @@
 import { TransactionSQL } from 'bun';
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, e as StrictColumnSelector, f as QueryBuilder } from '../index-BdpoD4zk.js';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, h as StrictColumnSelector, i as QueryBuilder, E as ExplainOptions } from '../index-CARBkj9h.js';
 import { Column } from '../column/index.js';
 import { Dialect } from '../table/constants.js';
-import '../column/constants.js';
 import '../types.js';
 import './constants.js';
+import '../column/constants.js';
 import '../column/types.js';
 
 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;
+declare function explain<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, options?: ExplainOptions): Promise<unknown>;
 declare function exec<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>, Output extends Query['_output'] = Query['_output']>(this: Query, tx?: TransactionSQL | null): Promise<Output>;
 
-export { buildQuery, exec, toQuery, toString };
+export { buildQuery, exec, explain, toDebugString, toQuery, toString };

package/dist/esm/query/sql.js

@@ -1,7 +1,9 @@
 import { Dialect } from '../table/constants.js';
 import { buildDeleteQuery, buildUpdateQuery, buildInsertQuery, buildSelectQuery } from './builder.js';
+import { compileJoin, compileAst } from './compiler.js';
 import { QueryType, QueryHooksType } from './constants.js';
-import { getWhereConditions, getGroupByConditions, parseAliasedRow } from './utilities.js';
+import { buildExplainQuery } from './explain.js';
+import { getGroupByConditions, sanitizeParams, parseAliasedRow } from './utilities.js';
 
 // src/query/sql.ts
 function buildQuery(query) {
@@ -11,62 +13,97 @@ function buildQuery(query) {
     return `$${index}`;
   });
 }
-function toQuery(dialect) {
-  let sql = "";
+function toQuery(dialect = this.table.dialect) {
+  const params = [];
+  const parts = [];
   switch (this.definition.queryType) {
     case QueryType.SELECT:
-      sql = buildSelectQuery(this);
+      parts.push(buildSelectQuery(this));
       break;
     case QueryType.INSERT:
-      sql = buildInsertQuery(this);
+      parts.push(buildInsertQuery(this, params));
       break;
     case QueryType.UPDATE:
-      sql = buildUpdateQuery(this);
+      parts.push(buildUpdateQuery(this, params));
       break;
     case QueryType.DELETE:
-      sql = buildDeleteQuery(this);
+      parts.push(buildDeleteQuery(this));
       break;
     default:
       throw new Error("No query type defined");
   }
   if (this.definition?.joins?.length) {
-    sql += ` ${this.definition.joins.join(" ")}`;
+    const joinParts = this.definition.joins.map(
+      (join) => compileJoin(dialect, join, params)
+    );
+    parts.push(...joinParts);
   }
-  const whereConditions = getWhereConditions(this);
-  if (whereConditions.length) {
-    sql += ` WHERE ${whereConditions.join(" ")}`;
+  if (this.definition.where) {
+    const whereConditions = compileAst(dialect, this.definition.where, params);
+    parts.push(`WHERE ${whereConditions}`);
   }
   const groupByConditions = getGroupByConditions(this);
   if (groupByConditions.length) {
-    sql += ` GROUP BY ${groupByConditions.join(", ")}`;
+    parts.push(`GROUP BY ${groupByConditions.join(", ")}`);
   }
-  if (this.definition?.having?.length) {
-    sql += ` HAVING ${this.definition.having.join(" ")}`;
+  if (this.definition?.having) {
+    const havingConditions = compileAst(
+      dialect,
+      this.definition.having,
+      params
+    );
+    parts.push(`HAVING ${havingConditions}`);
   }
   if (this.definition?.orderBy?.length) {
-    sql += ` ORDER BY ${this.definition.orderBy.map((order) => [order.column, order.direction].join(" ")).join(", ")}`;
+    parts.push(
+      `ORDER BY ${this.definition.orderBy.map((order) => `${order.column} ${order.direction}`).join(", ")}`
+    );
   }
-  if (this.definition?.limit !== null) {
-    sql += ` LIMIT ?`;
-    if (!this.definition.params) this.definition.params = [];
-    this.definition.params.push(this.definition.limit);
+  if (this.definition?.limit != null) {
+    parts.push("LIMIT ?");
+    params.push(this.definition.limit);
   }
-  if (this.definition?.offset !== null) {
-    sql += ` OFFSET ?`;
-    if (!this.definition.params) this.definition.params = [];
-    this.definition.params.push(this.definition.offset);
+  if (this.definition?.offset != null) {
+    parts.push("OFFSET ?");
+    params.push(this.definition.offset);
   }
   if (this.definition.queryType === QueryType.UPDATE || this.definition.queryType === QueryType.DELETE) {
     if (dialect !== Dialect.MYSQL) {
-      sql += ` RETURNING *`;
+      parts.push("RETURNING *");
     }
   }
-  sql = buildQuery(sql);
-  return { query: sql + ";", params: this.definition.params };
+  const sql = buildQuery(parts.join(" "));
+  return { query: `${sql};`, params };
 }
 function toString() {
   return this.toQuery().query;
 }
+function toDebugString() {
+  const { query, params } = this.toQuery();
+  if (!params || params.length === 0) {
+    return query;
+  }
+  let debugQuery = query;
+  sanitizeParams(params).forEach((param, index) => {
+    const value = param === null ? "NULL" : `'${String(param).replace(/'/g, "''")}'`;
+    debugQuery = debugQuery.replace(
+      new RegExp(`\\$${index + 1}\\b`, "g"),
+      value
+    );
+  });
+  return debugQuery;
+}
+function explain(options = {}) {
+  const { query, params } = this.toQuery();
+  const explainPrefix = buildExplainQuery(this, options);
+  if (!this.table.client) {
+    throw new Error("Database client not defined");
+  }
+  return this.table.client.exec({
+    sql: `${explainPrefix}${query}`,
+    params
+  });
+}
 async function exec(tx) {
   const client = this.table.client;
   const dialect = this.table.dialect;
@@ -125,4 +162,4 @@ async function exec(tx) {
   );
 }
 
-export { buildQuery, exec, toQuery, toString };
+export { buildQuery, exec, explain, toDebugString, toQuery, toString };

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

@@ -1,8 +1,8 @@
+import 'bun';
 import '../column/index.js';
 import '../column/constants.js';
-export { l as AcceptedInsertValues, k as AcceptedOrderBy, m as AcceptedUpdateValues, n as AggregateColumn, A as AliasedColumn, C as ColumnSelector, h as QuerHooks, Q as QueryDefinition, p as QueryOutput, j as QueryRunHooks, q as QueryRunHooksOptions, R as RawColumn, o as SelectQueryOutput, g as SelectableColumn, e as StrictColumnSelector, W as WhereValue } from '../index-BdpoD4zk.js';
+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-CARBkj9h.js';
 import '../types.js';
 import './constants.js';
 import '../table/constants.js';
 import '../column/types.js';
-import 'bun';

package/dist/esm/query/utilities.d.ts

@@ -1,17 +1,16 @@
-import { T as Table, W as WhereValue, Q as QueryDefinition, C as ColumnSelector, e as StrictColumnSelector, f as QueryBuilder, A as AliasedColumn, g as SelectableColumn } from '../index-BdpoD4zk.js';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, h as StrictColumnSelector, i as QueryBuilder, A as AliasedColumn, j as SelectableColumn } from '../index-CARBkj9h.js';
 import { Column } from '../column/index.js';
-import { Dialect } from '../table/constants.js';
-import { AcceptedOperator } from './constants.js';
-import '../column/constants.js';
-import '../types.js';
 import 'bun';
+import '../types.js';
+import './constants.js';
+import '../column/constants.js';
+import '../table/constants.js';
 import '../column/types.js';
 
 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, }: {
@@ -33,5 +31,6 @@ declare function parseAliasedRow({ row, selects, root, }: {
     selects: SelectableColumn<string>[];
     root?: string | null;
 }): Record<string, any>;
+declare function sanitizeParams(params: unknown[]): (string | number | bigint | boolean | null)[];
 
-export { getCondition, getGroupByConditions, getParanoid, getTableColumnNames, getTableSelectName, getTimestamp, getWhereConditions, parseAliasedRow };
+export { getGroupByConditions, getParanoid, getTableColumnNames, getTableSelectName, getTimestamp, parseAliasedRow, sanitizeParams };