@dockstat/sqlite-wrapper 1.2.7 → 1.3.0

package/query-builder/index.ts

@@ -1,19 +1,19 @@
-import type { Database, SQLQueryBindings } from "bun:sqlite";
+import type { Database, SQLQueryBindings } from "bun:sqlite"
 import type {
   ColumnNames,
-  WhereCondition,
-  RegexCondition,
-  InsertResult,
-  UpdateResult,
   DeleteResult,
   InsertOptions,
-  JsonColumnConfig,
+  InsertResult,
+  Parser,
   QueryBuilderState,
-} from "../types";
-import { SelectQueryBuilder } from "./select";
-import { InsertQueryBuilder } from "./insert";
-import { UpdateQueryBuilder } from "./update";
-import { DeleteQueryBuilder } from "./delete";
+  RegexCondition,
+  UpdateResult,
+  WhereCondition,
+} from "../types"
+import { DeleteQueryBuilder } from "./delete"
+import { InsertQueryBuilder } from "./insert"
+import { SelectQueryBuilder } from "./select"
+import { UpdateQueryBuilder } from "./update"
 
 /**
  * Main QueryBuilder class that combines all functionality using composition.
@@ -26,40 +26,31 @@ import { DeleteQueryBuilder } from "./delete";
  * - DELETE: safe deletes with mandatory WHERE conditions
  * - WHERE: shared conditional logic across all operations
  */
-export class QueryBuilder<T extends Record<string, unknown>> {
-  private selectBuilder: SelectQueryBuilder<T>;
-  private insertBuilder: InsertQueryBuilder<T>;
-  private updateBuilder: UpdateQueryBuilder<T>;
-  private deleteBuilder: DeleteQueryBuilder<T>;
-
-  constructor(
-    db: Database,
-    tableName: string,
-    jsonConfig?: JsonColumnConfig<T>,
-  ) {
+export class QueryBuilder<T extends Record<string, unknown> = Record<string, unknown>> {
+  private selectBuilder: SelectQueryBuilder<T>
+  private insertBuilder: InsertQueryBuilder<T>
+  private updateBuilder: UpdateQueryBuilder<T>
+  private deleteBuilder: DeleteQueryBuilder<T>
+
+  constructor(db: Database, tableName: string, parser: Parser<T>) {
     // Create instances of each specialized builder
-    this.selectBuilder = new SelectQueryBuilder<T>(db, tableName, jsonConfig);
-    this.insertBuilder = new InsertQueryBuilder<T>(db, tableName, jsonConfig);
-    this.updateBuilder = new UpdateQueryBuilder<T>(db, tableName, jsonConfig);
-    this.deleteBuilder = new DeleteQueryBuilder<T>(db, tableName, jsonConfig);
+    this.selectBuilder = new SelectQueryBuilder<T>(db, tableName, parser)
+    this.insertBuilder = new InsertQueryBuilder<T>(db, tableName, parser)
+    this.updateBuilder = new UpdateQueryBuilder<T>(db, tableName, parser)
+    this.deleteBuilder = new DeleteQueryBuilder<T>(db, tableName, parser)
 
     // Ensure all builders share the same state for WHERE conditions
-    this.syncBuilderStates();
+    this.syncBuilderStates()
   }
 
   /**
    * Synchronize the state between all builders so WHERE conditions are shared.
    */
   private syncBuilderStates(): void {
-    const masterState = (
-      this.selectBuilder as unknown as { state: QueryBuilderState<T> }
-    ).state;
-    (this.insertBuilder as unknown as { state: QueryBuilderState<T> }).state =
-      masterState;
-    (this.updateBuilder as unknown as { state: QueryBuilderState<T> }).state =
-      masterState;
-    (this.deleteBuilder as unknown as { state: QueryBuilderState<T> }).state =
-      masterState;
+    const masterState = (this.selectBuilder as unknown as { state: QueryBuilderState<T> }).state
+    ;(this.insertBuilder as unknown as { state: QueryBuilderState<T> }).state = masterState
+    ;(this.updateBuilder as unknown as { state: QueryBuilderState<T> }).state = masterState
+    ;(this.deleteBuilder as unknown as { state: QueryBuilderState<T> }).state = masterState
   }
 
   // ===== WHERE METHODS (delegated to selectBuilder) =====
@@ -68,96 +59,88 @@ export class QueryBuilder<T extends Record<string, unknown>> {
    * Add simple equality conditions to the WHERE clause.
    */
   where(conditions: WhereCondition<T>): this {
-    this.selectBuilder.where(conditions);
-    return this;
+    this.selectBuilder.where(conditions)
+    return this
   }
 
   /**
    * Add regex conditions (applied client-side).
    */
   whereRgx(conditions: RegexCondition<T>): this {
-    this.selectBuilder.whereRgx(conditions);
-    return this;
+    this.selectBuilder.whereRgx(conditions)
+    return this
   }
 
   /**
    * Add a raw SQL WHERE fragment with parameter binding.
    */
   whereExpr(expr: string, params: SQLQueryBindings[] = []): this {
-    this.selectBuilder.whereExpr(expr, params);
-    return this;
+    this.selectBuilder.whereExpr(expr, params)
+    return this
   }
 
   /**
    * Alias for whereExpr.
    */
   whereRaw(expr: string, params: SQLQueryBindings[] = []): this {
-    this.selectBuilder.whereRaw(expr, params);
-    return this;
+    this.selectBuilder.whereRaw(expr, params)
+    return this
   }
 
   /**
    * Add an IN clause with proper parameter binding.
    */
   whereIn(column: keyof T, values: SQLQueryBindings[]): this {
-    this.selectBuilder.whereIn(column, values);
-    return this;
+    this.selectBuilder.whereIn(column, values)
+    return this
   }
 
   /**
    * Add a NOT IN clause with proper parameter binding.
    */
   whereNotIn(column: keyof T, values: SQLQueryBindings[]): this {
-    this.selectBuilder.whereNotIn(column, values);
-    return this;
+    this.selectBuilder.whereNotIn(column, values)
+    return this
   }
 
   /**
    * Add a comparison operator condition.
    */
   whereOp(column: keyof T, op: string, value: SQLQueryBindings): this {
-    this.selectBuilder.whereOp(column, op, value);
-    return this;
+    this.selectBuilder.whereOp(column, op, value)
+    return this
   }
 
   /**
    * Add a BETWEEN condition.
    */
-  whereBetween(
-    column: keyof T,
-    min: SQLQueryBindings,
-    max: SQLQueryBindings,
-  ): this {
-    this.selectBuilder.whereBetween(column, min, max);
-    return this;
+  whereBetween(column: keyof T, min: SQLQueryBindings, max: SQLQueryBindings): this {
+    this.selectBuilder.whereBetween(column, min, max)
+    return this
   }
 
   /**
    * Add a NOT BETWEEN condition.
    */
-  whereNotBetween(
-    column: keyof T,
-    min: SQLQueryBindings,
-    max: SQLQueryBindings,
-  ): this {
-    this.selectBuilder.whereNotBetween(column, min, max);
-    return this;
+  whereNotBetween(column: keyof T, min: SQLQueryBindings, max: SQLQueryBindings): this {
+    this.selectBuilder.whereNotBetween(column, min, max)
+    return this
   }
 
   /**
    * Add an IS NULL condition.
    */
   whereNull(column: keyof T): this {
-    this.selectBuilder.whereNull(column);
-    return this;
+    this.selectBuilder.whereNull(column)
+    return this
   }
 
   /**
    * Add an IS NOT NULL condition.
    */
   whereNotNull(column: keyof T): this {
-    this.selectBuilder.whereNotNull(column);
-    return this;
+    this.selectBuilder.whereNotNull(column)
+    return this
   }
 
   // ===== SELECT METHODS (delegated to selectBuilder) =====
@@ -166,48 +149,48 @@ export class QueryBuilder<T extends Record<string, unknown>> {
    * Specify which columns to select.
    */
   select(columns: ColumnNames<T>): this {
-    this.selectBuilder.select(columns);
-    return this;
+    this.selectBuilder.select(columns)
+    return this
   }
 
   /**
    * Add ORDER BY clause.
    */
   orderBy(column: keyof T): this {
-    this.selectBuilder.orderBy(column);
-    return this;
+    this.selectBuilder.orderBy(column)
+    return this
   }
 
   /**
    * Set order direction to descending.
    */
   desc(): this {
-    this.selectBuilder.desc();
-    return this;
+    this.selectBuilder.desc()
+    return this
   }
 
   /**
    * Set order direction to ascending.
    */
   asc(): this {
-    this.selectBuilder.asc();
-    return this;
+    this.selectBuilder.asc()
+    return this
   }
 
   /**
    * Add LIMIT clause.
    */
   limit(amount: number): this {
-    this.selectBuilder.limit(amount);
-    return this;
+    this.selectBuilder.limit(amount)
+    return this
   }
 
   /**
    * Add OFFSET clause.
    */
   offset(start: number): this {
-    this.selectBuilder.offset(start);
-    return this;
+    this.selectBuilder.offset(start)
+    return this
   }
 
   // ===== SELECT EXECUTION METHODS (delegated to selectBuilder) =====
@@ -216,49 +199,49 @@ export class QueryBuilder<T extends Record<string, unknown>> {
    * Execute the query and return all matching rows.
    */
   all(): T[] {
-    return this.selectBuilder.all();
+    return this.selectBuilder.all()
   }
 
   /**
    * Execute the query and return the first matching row, or null.
    */
   get(): T | null {
-    return this.selectBuilder.get();
+    return this.selectBuilder.get()
   }
 
   /**
    * Execute the query and return the first matching row, or null.
    */
   first(): T | null {
-    return this.selectBuilder.first();
+    return this.selectBuilder.first()
   }
 
   /**
    * Execute a COUNT query and return the number of matching rows.
    */
   count(): number {
-    return this.selectBuilder.count();
+    return this.selectBuilder.count()
   }
 
   /**
    * Check if any rows match the current conditions.
    */
   exists(): boolean {
-    return this.selectBuilder.exists();
+    return this.selectBuilder.exists()
   }
 
   /**
    * Execute the query and return a single column value from the first row.
    */
   value<K extends keyof T>(column: K): T[K] | null {
-    return this.selectBuilder.value(column);
+    return this.selectBuilder.value(column)
   }
 
   /**
    * Execute the query and return an array of values from a single column.
    */
   pluck<K extends keyof T>(column: K): T[K][] {
-    return this.selectBuilder.pluck(column);
+    return this.selectBuilder.pluck(column)
   }
 
   // ===== INSERT METHODS (delegated to insertBuilder) =====
@@ -266,60 +249,57 @@ export class QueryBuilder<T extends Record<string, unknown>> {
   /**
    * Insert a single row or multiple rows into the table.
    */
-  insert(
-    data: Partial<T> | Partial<T>[],
-    options?: InsertOptions,
-  ): InsertResult {
-    return this.insertBuilder.insert(data, options);
+  insert(data: Partial<T> | Partial<T>[], options?: InsertOptions): InsertResult {
+    return this.insertBuilder.insert(data, options)
   }
 
   /**
    * Insert with OR IGNORE conflict resolution.
    */
   insertOrIgnore(data: Partial<T> | Partial<T>[]): InsertResult {
-    return this.insertBuilder.insertOrIgnore(data);
+    return this.insertBuilder.insertOrIgnore(data)
   }
 
   /**
    * Insert with OR REPLACE conflict resolution.
    */
   insertOrReplace(data: Partial<T> | Partial<T>[]): InsertResult {
-    return this.insertBuilder.insertOrReplace(data);
+    return this.insertBuilder.insertOrReplace(data)
   }
 
   /**
    * Insert with OR ABORT conflict resolution.
    */
   insertOrAbort(data: Partial<T> | Partial<T>[]): InsertResult {
-    return this.insertBuilder.insertOrAbort(data);
+    return this.insertBuilder.insertOrAbort(data)
   }
 
   /**
    * Insert with OR FAIL conflict resolution.
    */
   insertOrFail(data: Partial<T> | Partial<T>[]): InsertResult {
-    return this.insertBuilder.insertOrFail(data);
+    return this.insertBuilder.insertOrFail(data)
   }
 
   /**
    * Insert with OR ROLLBACK conflict resolution.
    */
   insertOrRollback(data: Partial<T> | Partial<T>[]): InsertResult {
-    return this.insertBuilder.insertOrRollback(data);
+    return this.insertBuilder.insertOrRollback(data)
   }
 
   /**
    * Insert and get the inserted row back.
    */
   insertAndGet(data: Partial<T>, options?: InsertOptions): T | null {
-    return this.insertBuilder.insertAndGet(data, options);
+    return this.insertBuilder.insertAndGet(data, options)
   }
 
   /**
    * Batch insert with transaction support.
    */
   insertBatch(rows: Partial<T>[], options?: InsertOptions): InsertResult {
-    return this.insertBuilder.insertBatch(rows, options);
+    return this.insertBuilder.insertBatch(rows, options)
   }
 
   // ===== UPDATE METHODS (delegated to updateBuilder) =====
@@ -328,44 +308,42 @@ export class QueryBuilder<T extends Record<string, unknown>> {
    * Update rows matching the WHERE conditions.
    */
   update(data: Partial<T>): UpdateResult {
-    return this.updateBuilder.update(data);
+    return this.updateBuilder.update(data)
   }
 
   /**
    * Update or insert (upsert) using INSERT OR REPLACE.
    */
   upsert(data: Partial<T>): UpdateResult {
-    return this.updateBuilder.upsert(data);
+    return this.updateBuilder.upsert(data)
   }
 
   /**
    * Increment a numeric column by a specified amount.
    */
   increment(column: keyof T, amount = 1): UpdateResult {
-    return this.updateBuilder.increment(column, amount);
+    return this.updateBuilder.increment(column, amount)
   }
 
   /**
    * Decrement a numeric column by a specified amount.
    */
   decrement(column: keyof T, amount = 1): UpdateResult {
-    return this.updateBuilder.decrement(column, amount);
+    return this.updateBuilder.decrement(column, amount)
   }
 
   /**
    * Update and get the updated rows back.
    */
   updateAndGet(data: Partial<T>): T[] {
-    return this.updateBuilder.updateAndGet(data);
+    return this.updateBuilder.updateAndGet(data)
   }
 
   /**
    * Batch update multiple rows with different values.
    */
-  updateBatch(
-    updates: Array<{ where: Partial<T>; data: Partial<T> }>,
-  ): UpdateResult {
-    return this.updateBuilder.updateBatch(updates);
+  updateBatch(updates: Array<{ where: Partial<T>; data: Partial<T> }>): UpdateResult {
+    return this.updateBuilder.updateBatch(updates)
   }
 
   // ===== DELETE METHODS (delegated to deleteBuilder) =====
@@ -374,14 +352,14 @@ export class QueryBuilder<T extends Record<string, unknown>> {
    * Delete rows matching the WHERE conditions.
    */
   delete(): DeleteResult {
-    return this.deleteBuilder.delete();
+    return this.deleteBuilder.delete()
   }
 
   /**
    * Delete and get the deleted rows back.
    */
   deleteAndGet(): T[] {
-    return this.deleteBuilder.deleteAndGet();
+    return this.deleteBuilder.deleteAndGet()
   }
 
   /**
@@ -389,43 +367,43 @@ export class QueryBuilder<T extends Record<string, unknown>> {
    */
   softDelete(
     deletedColumn: keyof T = "deleted_at" as keyof T,
-    deletedValue: SQLQueryBindings = Math.floor(Date.now() / 1000),
+    deletedValue: SQLQueryBindings = Math.floor(Date.now() / 1000)
   ): DeleteResult {
-    return this.deleteBuilder.softDelete(deletedColumn, deletedValue);
+    return this.deleteBuilder.softDelete(deletedColumn, deletedValue)
   }
 
   /**
    * Restore soft deleted rows.
    */
   restore(deletedColumn: keyof T = "deleted_at" as keyof T): DeleteResult {
-    return this.deleteBuilder.restore(deletedColumn);
+    return this.deleteBuilder.restore(deletedColumn)
   }
 
   /**
    * Batch delete multiple sets of rows.
    */
   deleteBatch(conditions: Array<Partial<T>>): DeleteResult {
-    return this.deleteBuilder.deleteBatch(conditions);
+    return this.deleteBuilder.deleteBatch(conditions)
   }
 
   /**
    * Truncate the entire table (delete all rows).
    */
   truncate(): DeleteResult {
-    return this.deleteBuilder.truncate();
+    return this.deleteBuilder.truncate()
   }
 
   /**
    * Delete rows older than a specified timestamp.
    */
   deleteOlderThan(timestampColumn: keyof T, olderThan: number): DeleteResult {
-    return this.deleteBuilder.deleteOlderThan(timestampColumn, olderThan);
+    return this.deleteBuilder.deleteOlderThan(timestampColumn, olderThan)
   }
 
   /**
    * Delete duplicate rows based on specified columns.
    */
   deleteDuplicates(columns: Array<keyof T>): DeleteResult {
-    return this.deleteBuilder.deleteDuplicates(columns);
+    return this.deleteBuilder.deleteDuplicates(columns)
   }
 }