@ignisia/sql 0.3.0 → 0.4.0

package/dist/cjs/{index-2jl8MRfX.d.cts → index-CZhrzE5r.d.cts}

@@ -1,6 +1,6 @@
 import { TransactionSQL } from 'bun';
 import { Column } from './column/index.cjs';
-import { T as Table, D as DatabaseDefinition, a as TimestampOptions, M as MergeTimestampParanoid, h as QuerHooks, b as DatabaseDialect, i as DatabaseOptions, f as QueryBuilder, j as QueryRunHooks } from './index-CnQVnCEI.cjs';
+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-CHxuUiO4.cjs';
 import { QueryHooksType } from './query/constants.cjs';
 import { Dialect } from './table/constants.cjs';
 import { AcceptedColumnTypes } from './column/constants.cjs';
@@ -77,7 +77,7 @@ interface ColumnAlterationContract<DbDialect extends Dialect, Tables extends Rec
 }
 
 declare class Database<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>, Definition extends Partial<DatabaseDefinition<DbDialect>> = DatabaseDefinition<DbDialect>> {
-    readonly hooks: Partial<QuerHooks>;
+    readonly hooks: Partial<QueryHooks>;
     readonly dialect: DbDialect;
     readonly defintion: Definition;
     readonly tables: Tables;

package/dist/cjs/index.d.cts

@@ -1,7 +1,7 @@
 export { Column } from './column/index.cjs';
-export { D as Database } from './index-2jl8MRfX.cjs';
+export { D as Database } from './index-CZhrzE5r.cjs';
 export { Migration } from './migration/index.cjs';
-export { f as QueryBuilder, T as Table } from './index-CnQVnCEI.cjs';
+export { l as QueryBuilder, T as Table } from './index-CHxuUiO4.cjs';
 import './table/constants.cjs';
 import './column/constants.cjs';
 import './column/types.cjs';

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

@@ -1,6 +1,6 @@
 import { Column } from '../column/index.cjs';
-import { D as Database } from '../index-2jl8MRfX.cjs';
-import { T as Table } from '../index-CnQVnCEI.cjs';
+import { D as Database } from '../index-CZhrzE5r.cjs';
+import { T as Table } from '../index-CHxuUiO4.cjs';
 import { Dialect } from '../table/constants.cjs';
 import { MigrationOptions, MigrationFn } from './type.cjs';
 import '../column/constants.cjs';

package/dist/cjs/migration/type.d.cts

@@ -1,6 +1,6 @@
 import { Column } from '../column/index.cjs';
-import { D as Database } from '../index-2jl8MRfX.cjs';
-import { T as Table } from '../index-CnQVnCEI.cjs';
+import { D as Database } from '../index-CZhrzE5r.cjs';
+import { T as Table } from '../index-CHxuUiO4.cjs';
 import { Dialect } from '../table/constants.cjs';
 import '../column/constants.cjs';
 import '../column/types.cjs';

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

@@ -1,9 +1,9 @@
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, e as StrictColumnSelector, f as QueryBuilder } from '../index-CnQVnCEI.cjs';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, k as StrictColumnSelector, l as QueryBuilder } from '../index-CHxuUiO4.cjs';
 import { Column } from '../column/index.cjs';
-import '../column/constants.cjs';
+import 'bun';
 import '../types.cjs';
 import './constants.cjs';
-import 'bun';
+import '../column/constants.cjs';
 import '../table/constants.cjs';
 import '../column/types.cjs';
 

package/dist/cjs/query/builder.js

@@ -59,7 +59,7 @@ function buildUpdateQuery(q) {
   } else {
     q.definition.params = updateParams;
   }
-  return `UPDATE ${q.table.name} SET ${keys.map((key) => `${key} = ?`.trim()).join(", ")}`;
+  return `UPDATE ${q.table.name} SET ${keys.map((key) => `${key} = ?`).join(", ")}`;
 }
 function buildDeleteQuery(q) {
   return `DELETE FROM ${q.table.name}`;

package/dist/cjs/query/condition/common.d.cts

@@ -0,0 +1,41 @@
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, k as StrictColumnSelector, W as WhereValue, l as QueryBuilder, n as QueryTransformerContract, o as QueryConditionContract } from '../../index-CHxuUiO4.cjs';
+import { Column } from '../../column/index.cjs';
+import { AcceptedOperator } from '../constants.cjs';
+import 'bun';
+import '../../types.cjs';
+import '../../column/constants.cjs';
+import '../../table/constants.cjs';
+import '../../column/types.cjs';
+
+declare function where<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>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value?: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+declare function or<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>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value?: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+declare function on<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>, ColName extends StrictAllowedColumn, Operator extends typeof AcceptedOperator.EQ | typeof AcceptedOperator.NE>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, columnA: ColName, operator: Operator, columnB: ColName): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+declare function having<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>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "having"> & {
+    having: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "having"> & {
+    having: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "having"> & {
+    having: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+declare function whereGroup<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>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, callback: (q: QueryBuilder<Alias, TableRef, JoinedTables>) => QueryBuilder<Alias, TableRef, JoinedTables>): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>;
+declare function orGroup<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>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, callback: (q: QueryBuilder<Alias, TableRef, JoinedTables>) => QueryBuilder<Alias, TableRef, JoinedTables>): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>;
+
+export { having, on, or, orGroup, where, whereGroup };

package/dist/cjs/query/condition/common.js

@@ -0,0 +1,62 @@
+'use strict';
+
+var constants = require('../constants');
+var core = require('./core');
+
+function where(column, operator, value) {
+  return core.addCondition(
+    this,
+    constants.ConditionClause.WHERE,
+    column,
+    operator,
+    value || null,
+    constants.LogicalOperator.AND,
+    false
+  );
+}
+function or(column, operator, value) {
+  return core.addCondition(
+    this,
+    constants.ConditionClause.WHERE,
+    column,
+    operator,
+    value || null,
+    constants.LogicalOperator.OR,
+    false
+  );
+}
+function on(columnA, operator, columnB) {
+  return core.addCondition(
+    this,
+    constants.ConditionClause.WHERE,
+    columnA,
+    operator,
+    columnB,
+    constants.LogicalOperator.ON,
+    false
+  );
+}
+function having(column, operator, value) {
+  return core.addCondition(
+    this,
+    constants.ConditionClause.HAVING,
+    column,
+    operator,
+    value,
+    constants.LogicalOperator.AND,
+    false
+  );
+}
+function whereGroup(callback) {
+  return core.addGroupCondition(this, constants.LogicalOperator.AND, callback, false);
+}
+function orGroup(callback) {
+  return core.addGroupCondition(this, constants.LogicalOperator.OR, callback, false);
+}
+
+exports.having = having;
+exports.on = on;
+exports.or = or;
+exports.orGroup = orGroup;
+exports.where = where;
+exports.whereGroup = whereGroup;

package/dist/cjs/query/condition/core.d.cts

@@ -0,0 +1,8 @@
+export { a as addCondition, b as addGroupCondition } from '../../index-CHxuUiO4.cjs';
+import '../../column/index.cjs';
+import '../constants.cjs';
+import 'bun';
+import '../../types.cjs';
+import '../../column/constants.cjs';
+import '../../table/constants.cjs';
+import '../../column/types.cjs';

package/dist/cjs/query/condition/core.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var __ = require('..');
+var constants = require('../constants');
+var utilities = require('../utilities');
+
+function addCondition(query, clause, column, operator, value, logical, negate) {
+  if (!query.table.dialect) {
+    throw new Error("No DB Dialect defined");
+  }
+  const isOn = logical === constants.LogicalOperator.ON;
+  const validClause = clause.toLowerCase();
+  let condition = utilities.getCondition(query.table.dialect, column, operator, value);
+  if (isOn) {
+    condition = condition.replace("?", value);
+  }
+  if (!query.definition[validClause]) query.definition[validClause] = [];
+  const logicalPrefix = query.definition[validClause].length > 0 ? isOn ? constants.LogicalOperator.AND : logical : "";
+  const not = negate ? "NOT " : "";
+  query.definition[validClause].push(
+    `${logicalPrefix} ${not}${condition}`.trim()
+  );
+  if (operator === constants.AcceptedOperator.IS_NULL || operator === constants.AcceptedOperator.IS_NOT_NULL) {
+    return query;
+  }
+  if (!query.definition.params) query.definition.params = [];
+  if (!isOn) {
+    if (operator === constants.AcceptedOperator.STARTS_WITH) {
+      query.definition.params.push(`${value}%`);
+    } else if (operator === constants.AcceptedOperator.ENDS_WITH) {
+      query.definition.params.push(`%${value}`);
+    } else if (Array.isArray(value)) {
+      query.definition.params.push(...value);
+    } else {
+      query.definition.params.push(value);
+    }
+  }
+  return query;
+}
+function addGroupCondition(query, logical, callback, negate) {
+  const sub = callback(new __.QueryBuilder(query.table));
+  const subDef = sub.definition;
+  if (!subDef.where?.length) return query;
+  const not = negate ? "NOT " : "";
+  const grouped = `${not}(${subDef.where.join(" ")})`;
+  if (!query.definition.where) query.definition.where = [];
+  const logicalPrefix = query.definition.where.length > 0 ? logical : "";
+  query.definition.where.push(`${logicalPrefix} ${grouped}`.trim());
+  if (subDef.params?.length) {
+    if (!query.definition.params) query.definition.params = [];
+    query.definition.params.push(...subDef.params);
+  }
+  return query;
+}
+
+exports.addCondition = addCondition;
+exports.addGroupCondition = addGroupCondition;

package/dist/cjs/query/condition/index.d.cts

@@ -0,0 +1,10 @@
+export { having, on, or, orGroup, where, whereGroup } from './common.cjs';
+export { a as addCondition, b as addGroupCondition, c as addRawCondition, e as rawHaving, d as rawOr, r as rawWhere } from '../../index-CHxuUiO4.cjs';
+export { havingNot, orNot, orNotGroup, whereNot, whereNotGroup } from './not.cjs';
+import '../../column/index.cjs';
+import '../../table/constants.cjs';
+import '../../column/constants.cjs';
+import '../../column/types.cjs';
+import '../constants.cjs';
+import 'bun';
+import '../../types.cjs';

package/dist/cjs/query/condition/index.js

@@ -0,0 +1,33 @@
+'use strict';
+
+var common = require('./common');
+var core = require('./core');
+var not = require('./not');
+var raw = require('./raw');
+
+
+
+Object.keys(common).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return common[k]; }
+	});
+});
+Object.keys(core).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return core[k]; }
+	});
+});
+Object.keys(not).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return not[k]; }
+	});
+});
+Object.keys(raw).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return raw[k]; }
+	});
+});

package/dist/cjs/query/condition/not.d.cts

@@ -0,0 +1,34 @@
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, k as StrictColumnSelector, W as WhereValue, l as QueryBuilder, n as QueryTransformerContract, o as QueryConditionContract } from '../../index-CHxuUiO4.cjs';
+import { Column } from '../../column/index.cjs';
+import { AcceptedOperator } from '../constants.cjs';
+import 'bun';
+import '../../types.cjs';
+import '../../column/constants.cjs';
+import '../../table/constants.cjs';
+import '../../column/types.cjs';
+
+declare function whereNot<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>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value?: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+declare function havingNot<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>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "having"> & {
+    having: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "having"> & {
+    having: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "having"> & {
+    having: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+declare function orNot<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>, ColName extends StrictAllowedColumn, Col extends ColName extends `${infer TableAlias}.${infer TableColumn}` ? TableAlias extends Alias ? TableRef['columns'][TableColumn] : JoinedTables[TableAlias]['columns'][TableColumn] : never, Operator extends AcceptedOperator, Value extends WhereValue<Col>[Operator]>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, column: ColName, operator: Operator, value?: Value): QueryBuilder<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>, QueryTransformerContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>, QueryConditionContract<Alias, TableRef, JoinedTables, Omit<Definition, "where"> & {
+    where: string[];
+}, ColumnSelector<Alias, TableRef, JoinedTables>, StrictColumnSelector<Alias, TableRef, JoinedTables>>>;
+declare function whereNotGroup<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>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, callback: (q: QueryBuilder<Alias, TableRef, JoinedTables>) => QueryBuilder<Alias, TableRef, JoinedTables>): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>;
+declare function orNotGroup<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>>(this: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, callback: (q: QueryBuilder<Alias, TableRef, JoinedTables>) => QueryBuilder<Alias, TableRef, JoinedTables>): QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn, QueryTransformerContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, QueryConditionContract<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>>;
+
+export { havingNot, orNot, orNotGroup, whereNot, whereNotGroup };

package/dist/cjs/query/condition/not.js

@@ -0,0 +1,51 @@
+'use strict';
+
+require('..');
+var constants = require('../constants');
+var core = require('./core');
+
+function whereNot(column, operator, value) {
+  return core.addCondition(
+    this,
+    constants.ConditionClause.WHERE,
+    column,
+    operator,
+    value || null,
+    constants.LogicalOperator.AND,
+    true
+  );
+}
+function havingNot(column, operator, value) {
+  return core.addCondition(
+    this,
+    constants.ConditionClause.HAVING,
+    column,
+    operator,
+    value,
+    constants.LogicalOperator.AND,
+    true
+  );
+}
+function orNot(column, operator, value) {
+  return core.addCondition(
+    this,
+    constants.ConditionClause.WHERE,
+    column,
+    operator,
+    value || null,
+    constants.LogicalOperator.OR,
+    true
+  );
+}
+function whereNotGroup(callback) {
+  return core.addGroupCondition(this, constants.LogicalOperator.AND, callback, true);
+}
+function orNotGroup(callback) {
+  return core.addGroupCondition(this, constants.LogicalOperator.OR, callback, true);
+}
+
+exports.havingNot = havingNot;
+exports.orNot = orNot;
+exports.orNotGroup = orNotGroup;
+exports.whereNot = whereNot;
+exports.whereNotGroup = whereNotGroup;

package/dist/cjs/query/condition/raw.d.cts

@@ -0,0 +1,8 @@
+export { c as addRawCondition, e as rawHaving, d as rawOr, r as rawWhere } from '../../index-CHxuUiO4.cjs';
+import '../../column/index.cjs';
+import '../constants.cjs';
+import 'bun';
+import '../../types.cjs';
+import '../../column/constants.cjs';
+import '../../table/constants.cjs';
+import '../../column/types.cjs';

package/dist/cjs/query/condition/raw.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var constants = require('../constants');
+var helper = require('../helper');
+
+function addRawCondition(query, clause, column, logical, params) {
+  const validClause = clause.toLowerCase();
+  if (!query.definition[validClause]) query.definition[validClause] = [];
+  const condition = column(helper.rawCol);
+  const logicalPrefix = query.definition[validClause].length > 0 ? logical : "";
+  query.definition[validClause].push(`${logicalPrefix} ${condition}`.trim());
+  if (!query.definition.params) query.definition.params = [];
+  if (typeof params === "undefined") {
+    return query;
+  }
+  if (Array.isArray(params)) {
+    query.definition.params.push(...params);
+  } else {
+    query.definition.params.push(params);
+  }
+  return query;
+}
+function rawWhere(column, params) {
+  return addRawCondition(
+    this,
+    constants.ConditionClause.WHERE,
+    column,
+    constants.LogicalOperator.AND,
+    params
+  );
+}
+function rawOr(column, params) {
+  return addRawCondition(
+    this,
+    constants.ConditionClause.WHERE,
+    column,
+    constants.LogicalOperator.OR,
+    params
+  );
+}
+function rawHaving(column, params) {
+  return addRawCondition(
+    this,
+    constants.ConditionClause.HAVING,
+    column,
+    constants.LogicalOperator.AND,
+    params
+  );
+}
+
+exports.addRawCondition = addRawCondition;
+exports.rawHaving = rawHaving;
+exports.rawOr = rawOr;
+exports.rawWhere = rawWhere;

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

@@ -1,6 +1,7 @@
 declare const LogicalOperator: {
     readonly AND: "AND";
     readonly OR: "OR";
+    readonly ON: "ON";
 };
 type LogicalOperator = (typeof LogicalOperator)[keyof typeof LogicalOperator];
 declare const ConditionClause: {
@@ -25,6 +26,12 @@ declare const AcceptedOperator: {
     readonly IS_NOT_NULL: "isNotNull";
     readonly BETWEEN: "between";
     readonly NOT_BETWEEN: "notBetween";
+    readonly STARTS_WITH: "startsWith";
+    readonly ENDS_WITH: "endsWith";
+    readonly REG_EXP: "regExp";
+    readonly NOT_REG_EXP: "notRegExp";
+    readonly RLIKE: "rlike";
+    readonly NOT_RLIKE: "notRlike";
 };
 type AcceptedOperator = (typeof AcceptedOperator)[keyof typeof AcceptedOperator];
 declare const QueryType: {
@@ -51,6 +58,8 @@ declare const AcceptedJoin: {
     readonly INNER: "INNER";
     readonly LEFT: "LEFT";
     readonly RIGHT: "RIGHT";
+    readonly FULL: "FULL OUTER";
+    readonly CROSS: "CROSS";
     readonly NATURAL: "NATURAL";
 };
 type AcceptedJoin = (typeof AcceptedJoin)[keyof typeof AcceptedJoin];
@@ -59,5 +68,22 @@ declare const QueryHooksType: {
     readonly BEFORE: "before";
 };
 type QueryHooksType = (typeof QueryHooksType)[keyof typeof QueryHooksType];
+declare const ExplainFormat: {
+    readonly JSON: "JSON";
+    readonly TEXT: "TEXT";
+    readonly YAML: "YAML";
+    readonly XML: "XML";
+};
+type ExplainFormat = (typeof ExplainFormat)[keyof typeof ExplainFormat];
+declare const ExplainClause: {
+    readonly FORMAT: "FORMAT";
+    readonly ANALYZE: "ANALYZE";
+    readonly VERBOSE: "VERBOSE";
+    readonly COSTS: "COSTS";
+    readonly BUFFERS: "BUFFERS";
+    readonly SUMMARY: "SUMMARY";
+    readonly TIMING: "TIMING";
+};
+type ExplainClause = (typeof ExplainClause)[keyof typeof ExplainClause];
 
-export { AcceptedJoin, AcceptedOperator, AggregationFunction, ConditionClause, LogicalOperator, OrderBy, QueryHooksType, QueryType };
+export { AcceptedJoin, AcceptedOperator, AggregationFunction, ConditionClause, ExplainClause, ExplainFormat, LogicalOperator, OrderBy, QueryHooksType, QueryType };

package/dist/cjs/query/constants.js

@@ -2,7 +2,8 @@
 
 const LogicalOperator = {
   AND: "AND",
-  OR: "OR"
+  OR: "OR",
+  ON: "ON"
 };
 const ConditionClause = {
   WHERE: "WHERE",
@@ -24,7 +25,13 @@ const AcceptedOperator = {
   IS_NULL: "isNull",
   IS_NOT_NULL: "isNotNull",
   BETWEEN: "between",
-  NOT_BETWEEN: "notBetween"
+  NOT_BETWEEN: "notBetween",
+  STARTS_WITH: "startsWith",
+  ENDS_WITH: "endsWith",
+  REG_EXP: "regExp",
+  NOT_REG_EXP: "notRegExp",
+  RLIKE: "rlike",
+  NOT_RLIKE: "notRlike"
 };
 const QueryType = {
   SELECT: "SELECT",
@@ -47,17 +54,36 @@ const AcceptedJoin = {
   INNER: "INNER",
   LEFT: "LEFT",
   RIGHT: "RIGHT",
+  FULL: "FULL OUTER",
+  CROSS: "CROSS",
   NATURAL: "NATURAL"
 };
 const QueryHooksType = {
   AFTER: "after",
   BEFORE: "before"
 };
+const ExplainFormat = {
+  JSON: "JSON",
+  TEXT: "TEXT",
+  YAML: "YAML",
+  XML: "XML"
+};
+const ExplainClause = {
+  FORMAT: "FORMAT",
+  ANALYZE: "ANALYZE",
+  VERBOSE: "VERBOSE",
+  COSTS: "COSTS",
+  BUFFERS: "BUFFERS",
+  SUMMARY: "SUMMARY",
+  TIMING: "TIMING"
+};
 
 exports.AcceptedJoin = AcceptedJoin;
 exports.AcceptedOperator = AcceptedOperator;
 exports.AggregationFunction = AggregationFunction;
 exports.ConditionClause = ConditionClause;
+exports.ExplainClause = ExplainClause;
+exports.ExplainFormat = ExplainFormat;
 exports.LogicalOperator = LogicalOperator;
 exports.OrderBy = OrderBy;
 exports.QueryHooksType = QueryHooksType;

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

@@ -1,8 +1,8 @@
 import 'bun';
-export { Y as QueryConditionContract, X as QueryTransformerContract } from '../index-CnQVnCEI.cjs';
+export { o as QueryConditionContract, n as QueryTransformerContract } from '../index-CHxuUiO4.cjs';
 import '../column/index.cjs';
 import '../table/constants.cjs';
 import './constants.cjs';
-import '../column/constants.cjs';
 import '../types.cjs';
+import '../column/constants.cjs';
 import '../column/types.cjs';

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

@@ -0,0 +1,12 @@
+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 'bun';
+import '../types.cjs';
+import './constants.cjs';
+import '../column/constants.cjs';
+import '../table/constants.cjs';
+import '../column/types.cjs';
+
+declare function buildExplainQuery<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>>(q: QueryBuilder<Alias, TableRef, JoinedTables, Definition, AllowedColumn, StrictAllowedColumn>, options: Partial<ExplainOptions>): string;
+
+export { buildExplainQuery };