@ignisia/sql 0.1.0 → 0.2.1

package/dist/database/types.d.ts

@@ -1,5 +1,5 @@
 import '../column/index.js';
-export { D as DatabaseDefinition, b as DatabaseDialect, f as DatabaseOptions, P as PostgresConfig, S as SqliteConfig } from '../index-DJhQVUY3.js';
+export { D as DatabaseDefinition, b as DatabaseDialect, g as DatabaseOptions, P as PostgresConfig, S as SqliteConfig } from '../index-FMT0YEO7.js';
 import '../table/constants.js';
 import '../column/constants.js';
 import '../column/types.js';

package/dist/database/types.js

@@ -0,0 +1 @@
+

package/dist/database/wrapper.d.ts

@@ -1,7 +1,7 @@
 import { SQL } from 'bun';
 import { Database } from 'bun:sqlite';
 import { Dialect } from '../table/constants.js';
-import { b as DatabaseDialect, P as PostgresConfig, S as SqliteConfig } from '../index-DJhQVUY3.js';
+import { b as DatabaseDialect, P as PostgresConfig, S as SqliteConfig } from '../index-FMT0YEO7.js';
 import '../column/index.js';
 import '../column/constants.js';
 import '../column/types.js';

package/dist/database/wrapper.js

@@ -1,9 +1,92 @@
-import {
-  DatabasePsql,
-  DatabaseSqlite
-} from "../chunk-HKTHKQLK.js";
-import "../chunk-GLOHF5CP.js";
-export {
-  DatabasePsql,
-  DatabaseSqlite
-};
+import { SQL } from 'bun';
+import { Database } from 'bun:sqlite';
+import { Dialect } from '../table/constants';
+
+class DatabasePsql {
+  dialect;
+  options;
+  client;
+  status;
+  constructor(options) {
+    this.dialect = Dialect.POSTGRES;
+    this.options = options;
+    this.status = "connecting";
+    this.client = new SQL({
+      ...options,
+      onconnect: () => {
+        this.status = "connected";
+      },
+      onclose: () => {
+        this.status = "disconnected";
+      }
+    });
+    this.connect();
+  }
+  async connect() {
+    await this.client.connect();
+    return this;
+  }
+  async disconnect() {
+    await this.client.close();
+    return this;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async exec(sql, values) {
+    if (!values) {
+      return this.client.unsafe(sql);
+    }
+    return this.client.unsafe(sql, values);
+  }
+  async transaction(fn) {
+    try {
+      await this.exec("BEGIN");
+      const result = await fn();
+      await this.exec("COMMIT");
+      return result;
+    } catch (err) {
+      await this.exec("ROLLBACK");
+      throw err;
+    }
+  }
+}
+class DatabaseSqlite {
+  dialect;
+  options;
+  client;
+  status;
+  constructor(options) {
+    this.dialect = Dialect.SQLITE;
+    this.options = options;
+    this.status = "connecting";
+    this.client = new Database(options.filename);
+    this.status = "connected";
+  }
+  async connect() {
+    this.client = new Database(this.options.filename);
+    this.status = "connected";
+    return this;
+  }
+  async disconnect() {
+    this.client.close();
+    this.status = "disconnected";
+    return this;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async exec(sql, params) {
+    const query = this.client.prepare(sql, params);
+    return query.all();
+  }
+  async transaction(fn) {
+    try {
+      await this.exec("BEGIN");
+      const result = await fn();
+      await this.exec("COMMIT");
+      return result;
+    } catch (err) {
+      await this.exec("ROLLBACK");
+      throw err;
+    }
+  }
+}
+
+export { DatabasePsql, DatabaseSqlite };

package/dist/{index-Dcm5xIpR.d.ts → index-DFrpzXEn.d.ts}

@@ -1,5 +1,6 @@
 import { Column } from './column/index.js';
-import { T as Table, D as DatabaseDefinition, a as TimestampOptions, M as MergeTimestampParanoid, b as DatabaseDialect, f as DatabaseOptions, d as QueryBuilder } from './index-DJhQVUY3.js';
+import { T as Table, D as DatabaseDefinition, a as TimestampOptions, M as MergeTimestampParanoid, f as QuerHooks, b as DatabaseDialect, g as DatabaseOptions, d as QueryBuilder, h as QueryRunHooks } from './index-FMT0YEO7.js';
+import { QueryHooksType } from './query/constants.js';
 import { Dialect } from './table/constants.js';
 import { AcceptedColumnTypes } from './column/constants.js';
 
@@ -75,6 +76,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 dialect: DbDialect;
     readonly defintion: Definition;
     readonly tables: Tables;
@@ -92,6 +94,8 @@ declare class Database<DbDialect extends Dialect, Tables extends Record<string,
     dropColumnNotNull: ColumnAlterationContract<DbDialect, Tables, Definition>['dropColumnNotNull'];
     protected constructor(options: DatabaseOptions<DbDialect, Tables>);
     table<TableName extends keyof Tables & string, Table extends Tables[TableName]>(tableName: TableName): QueryBuilder<TableName, Table>;
+    addHook(type: QueryHooksType, fn: QueryRunHooks): this;
+    removeHook(type: QueryHooksType, fn: QueryRunHooks): this;
     transaction<T, U extends () => Promise<T>>(fn: U): Promise<unknown>;
     static define<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>>(options: DatabaseOptions<DbDialect, Tables>): Database<DbDialect, Tables, DatabaseDefinition<DbDialect>>;
 }

package/dist/{index-DJhQVUY3.d.ts → index-FMT0YEO7.d.ts}

@@ -1,7 +1,7 @@
 import { Column } from './column/index.js';
 import { AcceptedColumnTypes } from './column/constants.js';
 import { UnionToIntersection } from './types.js';
-import { QueryType, OrderBy, AggregationFunction, AcceptedOperator, ConditionClause, LogicalOperator } from './query/constants.js';
+import { QueryType, OrderBy, AggregationFunction, QueryHooksType, AcceptedOperator, ConditionClause, LogicalOperator } from './query/constants.js';
 import { Dialect } from './table/constants.js';
 
 type ColumnSelector<Alias extends string, TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>>> = `${Alias}."${keyof TableRef['columns'] & string}"` | `${Alias}.*` | {
@@ -118,6 +118,19 @@ type SelectQueryOutput<Alias extends string, TableRef extends Table<string, Reco
 type QueryOutput<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>> = Definition extends {
     queryType: infer Type;
 } ? Type extends null ? never : Type extends typeof QueryType.INSERT | typeof QueryType.UPDATE | typeof QueryType.DELETE ? InsertUpdateDeleteQueryOutput<TableRef>[] : Type extends typeof QueryType.SELECT ? SelectQueryOutput<Alias, TableRef, JoinedTables, Definition, AllowedColumn>[] : never : never;
+interface QueryRunHooksOptions {
+    query: string;
+    hook: QueryHooksType;
+    params: unknown[] | null | undefined;
+    type: QueryType;
+}
+interface QueryRunHooks {
+    (options: QueryRunHooksOptions): void;
+}
+interface QuerHooks {
+    after: Set<QueryRunHooks>;
+    before: Set<QueryRunHooks>;
+}
 
 declare const createdAt: Column<AcceptedColumnTypes, number | readonly string[], {
     type: "DATETIME";
@@ -190,7 +203,7 @@ interface DatabaseDialect {
 }
 
 declare class Table<TableName extends string, Columns extends Record<string, Column>, DbDialect extends Dialect = Dialect, CreatedAt extends string = string, UpdatedAt extends string = string, Timestamp extends TimestampOptions<CreatedAt, UpdatedAt> | boolean = TimestampOptions<CreatedAt, UpdatedAt> | boolean, Paranoid extends string | boolean = string | boolean> {
-    database: DatabaseDialect | null;
+    client: DatabaseDialect | null;
     readonly dialect: DbDialect;
     readonly name: TableName;
     readonly columns: Columns;
@@ -262,6 +275,7 @@ interface QueryConditionContract<Alias extends string, TableRef extends Table<st
 }
 
 declare class QueryBuilder<Alias extends TableRef['name'], TableRef extends Table<string, Record<string, Column>>, JoinedTables extends Record<string, Table<string, Record<string, Column>>> = NonNullable<unknown>, Definition extends Partial<QueryDefinition<Alias, TableRef, JoinedTables>> = NonNullable<unknown>, AllowedColumn extends ColumnSelector<Alias, TableRef, JoinedTables> = ColumnSelector<Alias, TableRef, JoinedTables>, StrictAllowedColumn extends StrictColumnSelector<Alias, TableRef, JoinedTables> = StrictColumnSelector<Alias, TableRef, JoinedTables>> {
+    readonly hooks: Partial<QuerHooks>;
     readonly table: TableRef;
     readonly definition: Definition;
     readonly _output: QueryOutput<Alias, TableRef, JoinedTables, Definition, AllowedColumn>;
@@ -341,4 +355,4 @@ declare class QueryBuilder<Alias extends TableRef['name'], TableRef extends Tabl
     infer(): this['_output'];
 }
 
-export { type AliasedColumn as A, rawHaving as B, type ColumnSelector as C, type DatabaseDefinition as D, addCondition as E, where as F, or as G, having as H, type QueryTransformerContract as I, type QueryConditionContract as J, type MergeTimestampParanoid as M, type PostgresConfig as P, type QueryDefinition as Q, type RawColumn as R, type SqliteConfig as S, Table as T, type WhereValue as W, type TimestampOptions as a, type DatabaseDialect as b, type StrictColumnSelector as c, QueryBuilder as d, type SelectableColumn as e, type DatabaseOptions as f, type AcceptedOrderBy as g, type AcceptedInsertValues as h, type AcceptedUpdateValues as i, type AggregateColumn as j, type SelectQueryOutput as k, type QueryOutput as l, createdAt as m, deletedAt as n, defineColumns as o, type TableOptions as p, type TableOutput as q, alias as r, clone as s, rawCol as t, updatedAt as u, col as v, aggregateCol as w, addRawCondition as x, rawWhere as y, rawOr as z };
+export { type AliasedColumn as A, addRawCondition as B, type ColumnSelector as C, type DatabaseDefinition as D, rawWhere as E, rawOr as F, rawHaving as G, addCondition as H, where as I, or as J, having as K, type QueryTransformerContract as L, type MergeTimestampParanoid as M, type QueryConditionContract as N, type PostgresConfig as P, type QueryDefinition as Q, type RawColumn as R, type SqliteConfig as S, Table as T, type WhereValue as W, type TimestampOptions as a, type DatabaseDialect as b, type StrictColumnSelector as c, QueryBuilder as d, type SelectableColumn as e, type QuerHooks as f, type DatabaseOptions as g, type QueryRunHooks as h, type AcceptedOrderBy as i, type AcceptedInsertValues as j, type AcceptedUpdateValues as k, type AggregateColumn as l, type SelectQueryOutput as m, type QueryOutput as n, type QueryRunHooksOptions as o, createdAt as p, deletedAt as q, defineColumns as r, type TableOptions as s, type TableOutput as t, updatedAt as u, alias as v, clone as w, rawCol as x, col as y, aggregateCol as z };

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 export { Column } from './column/index.js';
-export { D as Database } from './index-Dcm5xIpR.js';
+export { D as Database } from './index-DFrpzXEn.js';
 export { Migration } from './migration/index.js';
-export { d as QueryBuilder, T as Table } from './index-DJhQVUY3.js';
+export { d as QueryBuilder, T as Table } from './index-FMT0YEO7.js';
 import './table/constants.js';
 import './column/constants.js';
 import './column/types.js';
+import './query/constants.js';
 import './migration/type.js';
 import './types.js';
-import './query/constants.js';

package/dist/index.js

@@ -1,32 +1,5 @@
-import {
-  Migration
-} from "./chunk-CIWX3UCZ.js";
-import {
-  Database
-} from "./chunk-4DQRB5XS.js";
-import "./chunk-HKTHKQLK.js";
-import "./chunk-JF7OSNH4.js";
-import "./chunk-D2ASIT4Q.js";
-import {
-  Table
-} from "./chunk-W2DR3ZVK.js";
-import {
-  QueryBuilder
-} from "./chunk-TQ2GXAE7.js";
-import "./chunk-MG2S4V4N.js";
-import "./chunk-FYSNJAGD.js";
-import "./chunk-WVJGTZFI.js";
-import {
-  Column
-} from "./chunk-GY7R637S.js";
-import "./chunk-G3LSCLIQ.js";
-import "./chunk-Y7FSRHH3.js";
-import "./chunk-V4OMHVJN.js";
-import "./chunk-GLOHF5CP.js";
-export {
-  Column,
-  Database,
-  Migration,
-  QueryBuilder,
-  Table
-};
+export { Column } from './column';
+export { Database } from './database';
+export { Migration } from './migration';
+export { QueryBuilder } from './query';
+export { Table } from './table';

package/dist/migration/index.d.ts

@@ -1,12 +1,12 @@
 import { Column } from '../column/index.js';
-import { D as Database } from '../index-Dcm5xIpR.js';
-import { T as Table } from '../index-DJhQVUY3.js';
+import { D as Database } from '../index-DFrpzXEn.js';
+import { T as Table } from '../index-FMT0YEO7.js';
 import { Dialect } from '../table/constants.js';
 import { MigrationOptions, MigrationFn } from './type.js';
 import '../column/constants.js';
 import '../column/types.js';
-import '../types.js';
 import '../query/constants.js';
+import '../types.js';
 
 declare class Migration<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>> {
     readonly db: Database<DbDialect, Tables>;

package/dist/migration/index.js

@@ -1,6 +1,48 @@
-import {
-  Migration
-} from "../chunk-CIWX3UCZ.js";
-export {
-  Migration
-};
+class Migration {
+  db;
+  _up;
+  _down;
+  constructor(options) {
+    this.db = options.db;
+    this._up = options.up;
+    this._down = options.down;
+  }
+  get up() {
+    return this._up;
+  }
+  get down() {
+    return this._down;
+  }
+  static setUp(migrator, fn) {
+    migrator._up = () => fn(migrator.db);
+    return migrator;
+  }
+  static setDown(migrator, fn) {
+    migrator._down = () => fn(migrator.db);
+    return migrator;
+  }
+  static define(db, options) {
+    const migration = new Migration({
+      db,
+      up: options?.up ? () => options.up(db) : null,
+      down: options?.down ? () => options.down(db) : null
+    });
+    return {
+      migration,
+      setUp(fn) {
+        return Migration.setUp(
+          migration,
+          fn
+        );
+      },
+      setDown(fn) {
+        return Migration.setDown(
+          migration,
+          fn
+        );
+      }
+    };
+  }
+}
+
+export { Migration };

package/dist/migration/runner.js

@@ -1,26 +1,14 @@
-import {
-  Table
-} from "../chunk-W2DR3ZVK.js";
-import "../chunk-TQ2GXAE7.js";
-import "../chunk-MG2S4V4N.js";
-import "../chunk-FYSNJAGD.js";
-import "../chunk-WVJGTZFI.js";
-import {
-  Column
-} from "../chunk-GY7R637S.js";
-import "../chunk-G3LSCLIQ.js";
-import "../chunk-Y7FSRHH3.js";
-import "../chunk-GLOHF5CP.js";
+import { Column } from '../column';
+import { Table } from '../table';
 
-// src/migration/runner.ts
-var nameColumn = Column.define({
+const nameColumn = Column.define({
   type: "TEXT",
   length: 255
 }).primaryKey().notNull();
-var runAtColumn = Column.define({
+const runAtColumn = Column.define({
   type: "DATETIME"
 }).notNull();
-var migrationTable = null;
+let migrationTable = null;
 async function runMigration(filePath, direction) {
   const migrationFile = await import(filePath);
   const fileName = filePath.split("/").pop();
@@ -39,7 +27,7 @@ async function runMigration(filePath, direction) {
       },
       dialect: migration.db.dialect
     });
-    migrationTable.database = migration.db.client;
+    migrationTable.client = migration.db.client;
     await migrationTable.create();
   }
   const fn = migration[direction];
@@ -64,6 +52,5 @@ async function runMigration(filePath, direction) {
     return query.delete().where('ignisia_migration."name"', "eq", fileName).exec();
   });
 }
-export {
-  runMigration
-};
+
+export { runMigration };

package/dist/migration/type.d.ts

@@ -1,11 +1,11 @@
 import { Column } from '../column/index.js';
-import { D as Database } from '../index-Dcm5xIpR.js';
-import { T as Table } from '../index-DJhQVUY3.js';
+import { D as Database } from '../index-DFrpzXEn.js';
+import { T as Table } from '../index-FMT0YEO7.js';
 import { Dialect } from '../table/constants.js';
 import '../column/constants.js';
 import '../column/types.js';
-import '../types.js';
 import '../query/constants.js';
+import '../types.js';
 
 interface MigrationOptions<DbDialect extends Dialect, Tables extends Record<string, Table<string, Record<string, Column>>>> {
     db: Database<DbDialect, Tables>;

package/dist/migration/type.js

@@ -0,0 +1 @@
+

package/dist/query/builder.d.ts

@@ -1,4 +1,4 @@
-import { T as Table, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder } from '../index-DJhQVUY3.js';
+import { T as Table, Q as QueryDefinition, C as ColumnSelector, c as StrictColumnSelector, d as QueryBuilder } from '../index-FMT0YEO7.js';
 import { Column } from '../column/index.js';
 import '../column/constants.js';
 import '../types.js';

package/dist/query/builder.js

@@ -1,16 +1,66 @@
-import {
-  buildDeleteQuery,
-  buildInsertQuery,
-  buildSelectQuery,
-  buildUpdateQuery
-} from "../chunk-TQ2GXAE7.js";
-import "../chunk-MG2S4V4N.js";
-import "../chunk-FYSNJAGD.js";
-import "../chunk-Y7FSRHH3.js";
-import "../chunk-GLOHF5CP.js";
-export {
-  buildDeleteQuery,
-  buildInsertQuery,
-  buildSelectQuery,
-  buildUpdateQuery
-};
+import { quoteIdentifier } from '../utilities';
+import { getTableSelectName } from './utilities';
+
+function buildSelectQuery(q) {
+  const from = getTableSelectName(q);
+  const columns = [];
+  if (q.definition.select?.length) {
+    for (const col of q.definition.select) {
+      if (typeof col === "object") {
+        const alias = quoteIdentifier(col.as.replace(/"/g, ""));
+        columns.push(`${col.column} AS ${alias}`);
+        continue;
+      }
+      if (!col.endsWith("*")) {
+        const alias = quoteIdentifier(col.replace(/"/g, ""));
+        columns.push(`${col} AS ${alias}`);
+        continue;
+      }
+      columns.push(col);
+    }
+  }
+  if (q.definition?.aggregates) {
+    for (const aggregate of q.definition.aggregates) {
+      columns.push(
+        `${aggregate.fn}(${aggregate.column}) AS ${quoteIdentifier(aggregate.as)}`
+      );
+    }
+  }
+  const distinct = q.definition.distinct ? "DISTINCT " : "";
+  return `SELECT ${distinct}${columns.join(", ")} FROM ${from}`;
+}
+function buildInsertQuery(q) {
+  const rows = q.definition?.insertValues;
+  if (!rows?.length) {
+    throw new Error(`INSERT requires values`);
+  }
+  const keys = Object.keys(rows[0]);
+  const columns = keys.map(quoteIdentifier).join(", ");
+  const rowPlaceholders = `(${keys.map(() => "?").join(", ")})`;
+  const placeholders = rows.map(() => rowPlaceholders).join(", ");
+  q.definition.params = rows.flatMap(
+    (row) => keys.map((key) => row[key])
+  );
+  return `INSERT INTO ${q.table.name} (${columns}) VALUES ${placeholders} RETURNING *`;
+}
+function buildUpdateQuery(q) {
+  if (!q.definition?.updateValues) {
+    throw new Error(`UPDATE requires values`);
+  }
+  let keys = Object.keys(q.definition.updateValues);
+  const updateParams = keys.map(
+    (key) => q.definition.updateValues[key]
+  );
+  keys = keys.map(quoteIdentifier);
+  if (q.definition?.params) {
+    q.definition.params = [...updateParams, ...q.definition.params];
+  } else {
+    q.definition.params = updateParams;
+  }
+  return `UPDATE ${q.table.name} SET ${keys.map((key) => `${key} = ?`.trim()).join(", ")}`;
+}
+function buildDeleteQuery(q) {
+  return `DELETE FROM ${q.table.name}`;
+}
+
+export { buildDeleteQuery, buildInsertQuery, buildSelectQuery, buildUpdateQuery };

package/dist/query/condition.d.ts

@@ -1,4 +1,4 @@
-export { E as addCondition, x as addRawCondition, H as having, G as or, B as rawHaving, z as rawOr, y as rawWhere, F as where } from '../index-DJhQVUY3.js';
+export { H as addCondition, B as addRawCondition, K as having, J as or, G as rawHaving, F as rawOr, E as rawWhere, I as where } from '../index-FMT0YEO7.js';
 import '../column/index.js';
 import './constants.js';
 import '../column/constants.js';

package/dist/query/condition.js

@@ -1,24 +1,97 @@
-import {
-  addCondition,
-  addRawCondition,
-  having,
-  or,
-  rawHaving,
-  rawOr,
-  rawWhere,
-  where
-} from "../chunk-TQ2GXAE7.js";
-import "../chunk-MG2S4V4N.js";
-import "../chunk-FYSNJAGD.js";
-import "../chunk-Y7FSRHH3.js";
-import "../chunk-GLOHF5CP.js";
-export {
-  addCondition,
-  addRawCondition,
-  having,
-  or,
-  rawHaving,
-  rawOr,
-  rawWhere,
-  where
-};
+import { LogicalOperator, ConditionClause, AcceptedOperator } from './constants';
+import { rawCol } from './helper';
+import { getCondition } from './utilities';
+
+function addRawCondition(query, clause, column, logical, params) {
+  const validClause = clause.toLowerCase();
+  if (!query.definition[validClause]) query.definition[validClause] = [];
+  const condition = column(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,
+    ConditionClause.WHERE,
+    column,
+    LogicalOperator.AND,
+    params
+  );
+}
+function rawOr(column, params) {
+  return addRawCondition(
+    this,
+    ConditionClause.WHERE,
+    column,
+    LogicalOperator.OR,
+    params
+  );
+}
+function rawHaving(column, params) {
+  return addRawCondition(
+    this,
+    ConditionClause.HAVING,
+    column,
+    LogicalOperator.AND,
+    params
+  );
+}
+function addCondition(query, clause, column, operator, value, logical) {
+  const validClause = clause.toLowerCase();
+  const condition = getCondition(query.table.dialect, column, operator, value);
+  if (!query.definition[validClause]) query.definition[validClause] = [];
+  const logicalPrefix = query.definition[validClause].length > 0 ? logical : "";
+  query.definition[validClause].push(`${logicalPrefix} ${condition}`.trim());
+  if (operator === AcceptedOperator.IS_NULL || operator === AcceptedOperator.IS_NOT_NULL) {
+    return query;
+  }
+  if (!query.definition.params) query.definition.params = [];
+  if (Array.isArray(value)) {
+    query.definition.params.push(...value);
+  } else {
+    query.definition.params.push(value);
+  }
+  return query;
+}
+function where(column, operator, value) {
+  return addCondition(
+    this,
+    ConditionClause.WHERE,
+    column,
+    operator,
+    value,
+    LogicalOperator.AND
+  );
+}
+function or(column, operator, value) {
+  return addCondition(
+    this,
+    ConditionClause.WHERE,
+    column,
+    operator,
+    value,
+    LogicalOperator.OR
+  );
+}
+function having(column, operator, value) {
+  return addCondition(
+    this,
+    ConditionClause.HAVING,
+    column,
+    operator,
+    value,
+    LogicalOperator.AND
+  );
+}
+
+export { addCondition, addRawCondition, having, or, rawHaving, rawOr, rawWhere, where };

package/dist/query/constants.d.ts

@@ -54,5 +54,10 @@ declare const AcceptedJoin: {
     readonly NATURAL: "NATURAL";
 };
 type AcceptedJoin = (typeof AcceptedJoin)[keyof typeof AcceptedJoin];
+declare const QueryHooksType: {
+    readonly AFTER: "after";
+    readonly BEFORE: "before";
+};
+type QueryHooksType = (typeof QueryHooksType)[keyof typeof QueryHooksType];
 
-export { AcceptedJoin, AcceptedOperator, AggregationFunction, ConditionClause, LogicalOperator, OrderBy, QueryType };
+export { AcceptedJoin, AcceptedOperator, AggregationFunction, ConditionClause, LogicalOperator, OrderBy, QueryHooksType, QueryType };