@ignisia/sql 0.2.2 → 0.4.0

package/dist/cjs/query/index.js

@@ -17,6 +17,8 @@ class QueryBuilder {
   clone;
   toQuery;
   toString;
+  toDebugString;
+  explain;
   exec;
   rawWhere;
   rawAnd;
@@ -25,33 +27,23 @@ class QueryBuilder {
   where;
   and;
   or;
+  on;
   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 = helper.alias.bind(this);
     this.clone = helper.clone.bind(this);
     this.toQuery = sql.toQuery.bind(this);
     this.toString = sql.toString.bind(this);
+    this.toDebugString = sql.toDebugString.bind(this);
+    this.explain = sql.explain.bind(this);
     this.exec = sql.exec.bind(this);
     this.rawWhere = condition.rawWhere.bind(this);
     this.rawHaving = condition.rawHaving.bind(this);
@@ -61,46 +53,36 @@ class QueryBuilder {
     this.having = condition.having.bind(this);
     this.and = this.where;
     this.or = condition.or.bind(this);
+    this.on = condition.on.bind(this);
+    this.whereGroup = condition.whereGroup.bind(this);
+    this.orGroup = condition.orGroup.bind(this);
+    this.not = {
+      where: condition.whereNot.bind(this),
+      having: condition.havingNot.bind(this),
+      or: condition.orNot.bind(this),
+      whereGroup: condition.whereNotGroup.bind(
+        this
+      ),
+      orGroup: condition.orNotGroup.bind(this)
+    };
   }
-  leftJoin(joinTable, alias2, baseColumn, joinColumn) {
-    return join.addJoin(
-      this,
-      constants.AcceptedJoin.LEFT,
-      alias2,
-      joinTable,
-      baseColumn,
-      joinColumn
-    );
+  leftJoin(joinTable, alias2) {
+    return join.prepareJoin(this, constants.AcceptedJoin.LEFT, joinTable, alias2);
   }
-  rightJoin(joinTable, alias2, baseColumn, joinColumn) {
-    return join.addJoin(
-      this,
-      constants.AcceptedJoin.RIGHT,
-      alias2,
-      joinTable,
-      baseColumn,
-      joinColumn
-    );
+  rightJoin(joinTable, alias2) {
+    return join.prepareJoin(this, constants.AcceptedJoin.RIGHT, joinTable, alias2);
   }
-  innerJoin(joinTable, alias2, baseColumn, joinColumn) {
-    return join.addJoin(
-      this,
-      constants.AcceptedJoin.INNER,
-      alias2,
-      joinTable,
-      baseColumn,
-      joinColumn
-    );
+  innerJoin(joinTable, alias2) {
+    return join.prepareJoin(this, constants.AcceptedJoin.INNER, joinTable, alias2);
   }
-  naturalJoin(joinTable, alias2, baseColumn, joinColumn) {
-    return join.addJoin(
-      this,
-      constants.AcceptedJoin.NATURAL,
-      alias2,
-      joinTable,
-      baseColumn,
-      joinColumn
-    );
+  fullJoin(joinTable, alias2) {
+    return join.prepareJoin(this, constants.AcceptedJoin.FULL, joinTable, alias2);
+  }
+  crossJoin(joinTable, alias2) {
+    return join.addNoOnJoin(this, constants.AcceptedJoin.CROSS, joinTable, alias2);
+  }
+  naturalJoin(joinTable, alias2) {
+    return join.prepareJoin(this, constants.AcceptedJoin.NATURAL, joinTable, alias2);
   }
   distinct() {
     this.definition.distinct = true;
@@ -154,22 +136,33 @@ class QueryBuilder {
   insert(...values) {
     this.definition.queryType = constants.QueryType.INSERT;
     if (!this.definition.insertValues) this.definition.insertValues = [];
-    const { isWithTimestamp, createdAt, updatedAt, timestamp } = utilities$1.getTimestamp(
-      this.table
-    );
-    if (isWithTimestamp) {
-      values = values.map((row) => ({
-        ...row,
-        [createdAt]: row[createdAt] ?? timestamp,
-        [updatedAt]: row[updatedAt] ?? timestamp
-      }));
-    }
+    const {
+      isWithTimestamp,
+      isHasCreatedAt,
+      isHasUpdatedAt,
+      createdAt,
+      updatedAt,
+      timestamp
+    } = utilities$1.getTimestamp(this.table);
+    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;
   }
   update(values) {
-    const { isWithTimestamp, updatedAt, timestamp } = utilities$1.getTimestamp(this.table);
-    if (isWithTimestamp) {
+    const { isWithTimestamp, isHasUpdatedAt, updatedAt, timestamp } = utilities$1.getTimestamp(this.table);
+    if (isWithTimestamp && isHasUpdatedAt) {
       values = {
         ...values,
         [updatedAt]: values[updatedAt] ?? timestamp
@@ -189,6 +182,17 @@ class QueryBuilder {
     this.definition.queryType = constants.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/cjs/query/join.d.cts

@@ -1,16 +1,29 @@
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder } from '../index-CwiFQh0I.cjs';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, k as StrictColumnSelector, l as QueryBuilder, n as QueryTransformerContract, o as QueryConditionContract } from '../index-CHxuUiO4.cjs';
 import { Column } from '../column/index.cjs';
 import { AcceptedJoin } from './constants.cjs';
-import '../column/constants.cjs';
+import 'bun';
 import '../types.cjs';
+import '../column/constants.cjs';
 import '../table/constants.cjs';
 import '../column/types.cjs';
 
-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"> & {
+}>(query: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, joinType: JoinType, joinTable: JoinTable, alias: JoinAlias): QueryBuilder<Alias, TableRef, FinalJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
     joins: string[];
     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: string[];
+        joinedTables: ReturnedJoinedTables;
+    }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>, QueryTransformerContract<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
+        joins: string[];
+        joinedTables: ReturnedJoinedTables;
+    }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>, QueryConditionContract<Alias, TableRef, ReturnedJoinedTables, Omit<Definition, "joins" | "joinedTables"> & {
+        joins: string[];
+        joinedTables: ReturnedJoinedTables;
+    }, ColumnSelector<Alias, TableRef, ReturnedJoinedTables>, StrictColumnSelector<Alias, TableRef, ReturnedJoinedTables>>>;
+};
 
-export { addJoin };
+export { addNoOnJoin, prepareJoin };

package/dist/cjs/query/join.js

@@ -1,18 +1,47 @@
 'use strict';
 
-function addJoin(query, joinType, alias, joinTable, baseColumn, joinColumn) {
+var _ = require('.');
+
+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(`${joinType} JOIN ${joinTable.name} AS ${alias}`);
   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?.length) {
+        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 (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 = {};
+      }
+      query.definition.joinedTables[alias] = joinTable;
+      if (subDef.joinedTables) {
+        Object.assign(query.definition.joinedTables, subDef.joinedTables);
+      }
+      return query;
+    }
+  };
+}
 
-exports.addJoin = addJoin;
+exports.addNoOnJoin = addNoOnJoin;
+exports.prepareJoin = prepareJoin;

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

@@ -1,17 +1,20 @@
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder } from '../index-CwiFQh0I.cjs';
+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 { Column } from '../column/index.cjs';
-import '../column/constants.cjs';
+import { Dialect } from '../table/constants.cjs';
 import '../types.cjs';
 import './constants.cjs';
-import '../table/constants.cjs';
+import '../column/constants.cjs';
 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): {
+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;
 };
 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 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): Promise<Output>;
+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/cjs/query/sql.js

@@ -1,7 +1,9 @@
 'use strict';
 
+var constants$1 = require('../table/constants');
 var builder = require('./builder');
 var constants = require('./constants');
+var explain$1 = require('./explain');
 var utilities = require('./utilities');
 
 function buildQuery(query) {
@@ -11,80 +13,135 @@ function buildQuery(query) {
     return `$${index}`;
   });
 }
-function toQuery() {
-  let sql = "";
+function toQuery(dialect) {
+  const parts = [];
   switch (this.definition.queryType) {
     case constants.QueryType.SELECT:
-      sql = builder.buildSelectQuery(this);
+      parts.push(builder.buildSelectQuery(this));
       break;
     case constants.QueryType.INSERT:
-      sql = builder.buildInsertQuery(this);
+      parts.push(builder.buildInsertQuery(this));
       break;
     case constants.QueryType.UPDATE:
-      sql = builder.buildUpdateQuery(this);
+      parts.push(builder.buildUpdateQuery(this));
       break;
     case constants.QueryType.DELETE:
-      sql = builder.buildDeleteQuery(this);
+      parts.push(builder.buildDeleteQuery(this));
       break;
     default:
       throw new Error("No query type defined");
   }
   if (this.definition?.joins?.length) {
-    sql += ` ${this.definition.joins.join(" ")}`;
+    parts.push(this.definition.joins.join(" "));
   }
   const whereConditions = utilities.getWhereConditions(this);
   if (whereConditions.length) {
-    sql += ` WHERE ${whereConditions.join(" ")}`;
+    parts.push(`WHERE ${whereConditions.join(" ")}`);
   }
   const groupByConditions = utilities.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(" ")}`;
+    parts.push(`HAVING ${this.definition.having.join(" ")}`);
   }
   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 ?`;
+    parts.push("LIMIT ?");
     if (!this.definition.params) this.definition.params = [];
     this.definition.params.push(this.definition.limit);
   }
   if (this.definition?.offset !== null) {
-    sql += ` OFFSET ?`;
+    parts.push("OFFSET ?");
     if (!this.definition.params) this.definition.params = [];
     this.definition.params.push(this.definition.offset);
   }
   if (this.definition.queryType === constants.QueryType.UPDATE || this.definition.queryType === constants.QueryType.DELETE) {
-    sql += ` RETURNING *`;
+    if (dialect !== constants$1.Dialect.MYSQL) {
+      parts.push("RETURNING *");
+    }
   }
-  sql = buildQuery(sql);
-  return { query: sql + ";", params: this.definition.params };
+  const sql = buildQuery(parts.join(" "));
+  return { query: `${sql};`, params: this.definition.params };
 }
 function toString() {
   return this.toQuery().query;
 }
-async function exec() {
-  if (!this.table.client) throw new Error("Database client not defined");
+function toDebugString() {
+  const { query, params } = this.toQuery();
+  if (!params || params.length === 0) {
+    return query;
+  }
+  let debugQuery = query;
+  utilities.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 = explain$1.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;
+  const queryType = this.definition.queryType;
+  const isUpdate = queryType === constants.QueryType.UPDATE;
+  const isDelete = queryType === constants.QueryType.DELETE;
+  const isReturning = isUpdate || isDelete;
+  const isMySQL = dialect === constants$1.Dialect.MYSQL;
+  if (!client) {
+    throw new Error("Database client not defined");
+  }
+  if (!queryType) {
+    throw new Error("No query type defined");
+  }
+  const { query, params } = this.toQuery(dialect);
   if (this.hooks?.before?.size) {
     for (const hook of this.hooks.before.values()) {
       hook({
         query,
         params,
-        type: this.definition.queryType,
+        type: queryType,
         hook: constants.QueryHooksType.BEFORE
       });
     }
   }
-  const result = await this.table.client.exec(query, params);
+  let 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({
+      sql: query2.toQuery().query,
+      params,
+      tx
+    });
+  }
   if (this.hooks?.after?.size) {
     for (const hook of this.hooks.after.values()) {
       hook({
         query,
         params,
-        type: this.definition.queryType,
+        type: queryType,
         hook: constants.QueryHooksType.AFTER
       });
     }
@@ -100,5 +157,7 @@ async function exec() {
 
 exports.buildQuery = buildQuery;
 exports.exec = exec;
+exports.explain = explain;
+exports.toDebugString = toDebugString;
 exports.toQuery = toQuery;
 exports.toString = toString;

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

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

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

@@ -1,9 +1,10 @@
-import { T as Table, W as WhereValue, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder, A as AliasedColumn, e as SelectableColumn } from '../index-CwiFQh0I.cjs';
+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 { Column } from '../column/index.cjs';
 import { Dialect } from '../table/constants.cjs';
 import { AcceptedOperator } from './constants.cjs';
-import '../column/constants.cjs';
+import 'bun';
 import '../types.cjs';
+import '../column/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): {
@@ -16,6 +17,8 @@ declare function getTimestamp<TableRef extends Table<string, Record<string, Colu
     timestamp: Date;
     createdAt: string;
     updatedAt: string;
+    isHasUpdatedAt: boolean;
+    isHasCreatedAt: boolean;
 };
 declare function getParanoid<TableRef extends Table<string, Record<string, Column>>>(table: TableRef): {
     isWithParanoid: boolean;
@@ -30,5 +33,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 { getCondition, getGroupByConditions, getParanoid, getTableColumnNames, getTableSelectName, getTimestamp, getWhereConditions, parseAliasedRow, sanitizeParams };

package/dist/cjs/query/utilities.js

@@ -55,6 +55,58 @@ function getCondition(dialect, column, operator, value) {
       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");
   }
@@ -62,22 +114,32 @@ function getCondition(dialect, column, operator, value) {
 function getTimestamp(table) {
   const isWithTimestamp = !!table.timestamp;
   const timestamp = /* @__PURE__ */ new Date();
+  let isHasCreatedAt = true;
+  let isHasUpdatedAt = true;
   let createdAt = "createdAt";
   let updatedAt = "updatedAt";
   if (isWithTimestamp) {
     const isCustomTimestamp = typeof table.timestamp === "object";
-    if (isCustomTimestamp && table.timestamp.createdAt) {
-      createdAt = table.timestamp.createdAt;
+    if (isCustomTimestamp) {
+      if (typeof table.timestamp.createdAt === "string") {
+        createdAt = table.timestamp.createdAt;
+      }
+      isHasCreatedAt = table.timestamp.createdAt !== false;
     }
-    if (isCustomTimestamp && table.timestamp.updatedAt) {
-      updatedAt = table.timestamp.updatedAt;
+    if (isCustomTimestamp) {
+      if (typeof table.timestamp.updatedAt === "string") {
+        updatedAt = table.timestamp.updatedAt;
+      }
+      isHasUpdatedAt = table.timestamp.updatedAt !== false;
     }
   }
   return {
     isWithTimestamp,
     timestamp,
     createdAt,
-    updatedAt
+    updatedAt,
+    isHasUpdatedAt,
+    isHasCreatedAt
   };
 }
 function getParanoid(table) {
@@ -173,6 +235,24 @@ function parseAliasedRow({
   }
   return result;
 }
+function sanitizeParams(params) {
+  return params.map((param) => {
+    if (param === null || typeof param === "string" || typeof param === "number" || typeof param === "boolean" || typeof param === "bigint") {
+      return param;
+    }
+    if (param === void 0) {
+      return null;
+    }
+    if (param instanceof Date) {
+      return param.toISOString();
+    }
+    try {
+      return JSON.stringify(param);
+    } catch {
+      return null;
+    }
+  });
+}
 
 exports.getCondition = getCondition;
 exports.getGroupByConditions = getGroupByConditions;
@@ -182,3 +262,4 @@ exports.getTableSelectName = getTableSelectName;
 exports.getTimestamp = getTimestamp;
 exports.getWhereConditions = getWhereConditions;
 exports.parseAliasedRow = parseAliasedRow;
+exports.sanitizeParams = sanitizeParams;

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

@@ -1,5 +1,6 @@
 declare const Dialect: {
     readonly POSTGRES: "postgres";
+    readonly MYSQL: "mysql";
     readonly SQLITE: "sqlite";
 };
 type Dialect = (typeof Dialect)[keyof typeof Dialect];

package/dist/cjs/table/constants.js

@@ -2,6 +2,7 @@
 
 const Dialect = {
   POSTGRES: "postgres",
+  MYSQL: "mysql",
   SQLITE: "sqlite"
 };