workers-qb 1.4.3 → 1.5.1

package/README.md

@@ -10,10 +10,12 @@ traditional ORM.
 `workers-qb` is not intended to provide ORM-like functionality, rather to make it easier to interact with the database
 from code for direct SQL access using convenient wrapper methods.
 
-Currently, 2 databases are supported:
+Currently, 3 databases are supported:
 
-- [Cloudflare D1](https://developers.cloudflare.com/d1/)
-- [PostgreSQL (using node-postgres)](https://developers.cloudflare.com/workers/databases/connect-to-postgres/)
+- [Cloudflare D1](https://workers-qb.massadas.com/databases/cloudflare-d1/)
+- [Cloudflare Durable Objects](https://workers-qb.massadas.com/databases/cloudflare-do/)
+- [PostgreSQL (using node-postgres)](https://workers-qb.massadas.com/databases/postgresql/)
+- [Bring your own Database](https://workers-qb.massadas.com/databases/bring-your-own-database/)
 
 ## Features
 
@@ -22,11 +24,9 @@ Currently, 2 databases are supported:
 - [x] [Type Checks for data read](https://workers-qb.massadas.com/type-check/)
 - [x] [Create/drop tables](https://workers-qb.massadas.com/basic-queries/#dropping-and-creating-tables)
 - [x] [Insert/Bulk Inserts/Update/Select/Delete/Join queries](https://workers-qb.massadas.com/basic-queries/)
+- [x] [Modular selects](https://workers-qb.massadas.com/modular-selects/)
 - [x] [On Conflict for Inserts and Updates](https://workers-qb.massadas.com/advanced-queries/onConflict/)
 - [x] [Upsert](https://workers-qb.massadas.com/advanced-queries/upsert/)
-- [x] [Support for Cloudflare Workers D1](https://workers-qb.massadas.com/databases/cloudflare-d1/)
-- [x] [Support for Cloudflare Workers PostgreSQL (using node-postgres)](https://workers-qb.massadas.com/databases/postgresql/)
-- [ ] Named parameters (waiting for full support in D1)
 
 ## Installation
 

package/dist/index.d.mts

@@ -1,5 +1,3 @@
-import { SqlStorage } from '@cloudflare/workers-types/experimental';
-
 declare enum OrderTypes {
     ASC = "ASC",
     DESC = "DESC"
@@ -33,12 +31,14 @@ declare class Query<Result = any> {
     fetchType?: FetchTypes;
     constructor(executeMethod: (query: Query<Result>) => Promise<Result>, query: string, args?: Primitive[], fetchType?: FetchTypes);
     execute(): Promise<Result>;
+    toObject(): RawQuery;
 }
 declare class QueryWithExtra<GenericResultWrapper, Result = any> extends Query<Result> {
     private countQuery;
     constructor(executeMethod: (query: Query<Result>) => Promise<Result>, query: string, countQuery: string, args?: Primitive[], fetchType?: FetchTypes);
     count(): Promise<CountResult<GenericResultWrapper>>;
 }
+declare function trimQuery(query: string): string;
 
 type OmitIndexSignature<ObjectType> = {
     [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType];
@@ -55,6 +55,12 @@ type SimpleMerge<Destination, Source> = {
 type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
 
 type Primitive = null | string | number | boolean | bigint | Raw;
+type QueryLoggerMeta = {
+    duration?: number;
+};
+type QueryBuilderOptions = {
+    logger?: (query: RawQuery, meta: QueryLoggerMeta) => void | Promise<void>;
+};
 type DefaultObject = Record<string, Primitive>;
 type DefaultReturnObject = Record<string, null | string | number | boolean | bigint>;
 type Where = {
@@ -169,8 +175,9 @@ type CountResult<GenericResultWrapper> = OneResult<GenericResultWrapper, {
 declare class SelectBuilder<GenericResultWrapper, GenericResult = DefaultReturnObject> {
     _debugger: boolean;
     private _options;
-    private _queryBuilder;
-    constructor(options: Partial<SelectAll>, queryBuilder: (params: SelectAll) => QueryWithExtra<GenericResultWrapper>);
+    private _fetchAll;
+    private _fetchOne;
+    constructor(options: Partial<SelectAll>, fetchAll: (params: SelectAll) => QueryWithExtra<GenericResultWrapper>, fetchOne: (params: SelectOne) => QueryWithExtra<GenericResultWrapper>);
     setDebugger(state: boolean): void;
     tableName(tableName: SelectAll['tableName']): SelectBuilder<GenericResultWrapper, GenericResult>;
     fields(fields: SelectAll['fields']): SelectBuilder<GenericResultWrapper, GenericResult>;
@@ -182,14 +189,19 @@ declare class SelectBuilder<GenericResultWrapper, GenericResult = DefaultReturnO
     offset(offset: SelectAll['offset']): SelectBuilder<GenericResultWrapper, GenericResult>;
     limit(limit: SelectAll['limit']): SelectBuilder<GenericResultWrapper, GenericResult>;
     private _parseArray;
-    getQuery(): Query<ArrayResult<GenericResultWrapper, GenericResult>>;
+    getQueryAll(): Query<ArrayResult<GenericResultWrapper, GenericResult>>;
+    getQueryOne(): Query<OneResult<GenericResultWrapper, GenericResult>>;
     execute(): Promise<ArrayResult<GenericResultWrapper, GenericResult>>;
+    all(): Promise<ArrayResult<GenericResultWrapper, GenericResult>>;
+    one(): Promise<OneResult<GenericResultWrapper, GenericResult>>;
     count(): Promise<CountResult<GenericResultWrapper>>;
 }
 
 declare class QueryBuilder<GenericResultWrapper> {
-    _debugger: boolean;
+    protected options: QueryBuilderOptions;
+    constructor(options?: QueryBuilderOptions);
     setDebugger(state: boolean): void;
+    loggerWrapper(query: Query | Query[], innerFunction: () => any): Promise<any>;
     execute(query: Query): Promise<any>;
     batchExecute(queryArray: Query[]): Promise<any[]>;
     createTable<GenericResult = undefined>(params: {
@@ -233,39 +245,23 @@ declare class QueryBuilder<GenericResultWrapper> {
 
 declare class D1QB extends QueryBuilder<D1Result> {
     db: any;
-    constructor(db: any);
+    constructor(db: any, options?: QueryBuilderOptions);
     execute(query: Query): Promise<any>;
     batchExecute(queryArray: Query[]): Promise<any>;
 }
 
 declare class PGQB extends QueryBuilder<PGResult> {
     db: any;
-    constructor(db: any);
+    constructor(db: any, options?: QueryBuilderOptions);
     connect(): Promise<void>;
     close(): Promise<void>;
-    execute(query: Query): Promise<{
-        command: any;
-        lastRowId: any;
-        rowCount: any;
-        results: any;
-    } | {
-        command: any;
-        lastRowId: any;
-        rowCount: any;
-        results?: undefined;
-    }>;
+    execute(query: Query): Promise<any>;
 }
 
 declare class DOQB extends QueryBuilder<{}> {
-    db: SqlStorage;
-    constructor(db: SqlStorage);
-    execute(query: Query): Promise<{
-        results: Record<string, string | number | ArrayBuffer | null> | undefined;
-    } | {
-        results: Record<string, string | number | ArrayBuffer | null>[];
-    }>;
-}
-declare class DurableObjectDatabaseQB extends DOQB {
+    db: any;
+    constructor(db: any, options?: QueryBuilderOptions);
+    execute(query: Query): Promise<any>;
 }
 
-export { type ArrayResult, ConflictTypes, type ConflictUpsert, type CountResult, type D1Meta, D1QB, type D1Result, DOQB, type DefaultObject, type DefaultReturnObject, type Delete, type DeleteReturning, type DeleteWithoutReturning, DurableObjectDatabaseQB, FetchTypes, type Insert, type InsertMultiple, type InsertOne, type InsertWithoutReturning, type Join, JoinTypes, type OneResult, OrderTypes, PGQB, type PGResult, type Primitive, Query, QueryBuilder, QueryWithExtra, Raw, type RawQuery, type RawQueryFetchAll, type RawQueryFetchOne, type RawQueryWithoutFetching, type SelectAll, type SelectOne, type Update, type UpdateReturning, type UpdateWithoutReturning, type Where, type test };
+export { type ArrayResult, ConflictTypes, type ConflictUpsert, type CountResult, type D1Meta, D1QB, type D1Result, DOQB, type DefaultObject, type DefaultReturnObject, type Delete, type DeleteReturning, type DeleteWithoutReturning, FetchTypes, type Insert, type InsertMultiple, type InsertOne, type InsertWithoutReturning, type Join, JoinTypes, type OneResult, OrderTypes, PGQB, type PGResult, type Primitive, Query, QueryBuilder, type QueryBuilderOptions, type QueryLoggerMeta, QueryWithExtra, Raw, type RawQuery, type RawQueryFetchAll, type RawQueryFetchOne, type RawQueryWithoutFetching, type SelectAll, type SelectOne, type Update, type UpdateReturning, type UpdateWithoutReturning, type Where, type test, trimQuery };

package/dist/index.d.ts

@@ -1,5 +1,3 @@
-import { SqlStorage } from '@cloudflare/workers-types/experimental';
-
 declare enum OrderTypes {
     ASC = "ASC",
     DESC = "DESC"
@@ -33,12 +31,14 @@ declare class Query<Result = any> {
     fetchType?: FetchTypes;
     constructor(executeMethod: (query: Query<Result>) => Promise<Result>, query: string, args?: Primitive[], fetchType?: FetchTypes);
     execute(): Promise<Result>;
+    toObject(): RawQuery;
 }
 declare class QueryWithExtra<GenericResultWrapper, Result = any> extends Query<Result> {
     private countQuery;
     constructor(executeMethod: (query: Query<Result>) => Promise<Result>, query: string, countQuery: string, args?: Primitive[], fetchType?: FetchTypes);
     count(): Promise<CountResult<GenericResultWrapper>>;
 }
+declare function trimQuery(query: string): string;
 
 type OmitIndexSignature<ObjectType> = {
     [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType];
@@ -55,6 +55,12 @@ type SimpleMerge<Destination, Source> = {
 type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
 
 type Primitive = null | string | number | boolean | bigint | Raw;
+type QueryLoggerMeta = {
+    duration?: number;
+};
+type QueryBuilderOptions = {
+    logger?: (query: RawQuery, meta: QueryLoggerMeta) => void | Promise<void>;
+};
 type DefaultObject = Record<string, Primitive>;
 type DefaultReturnObject = Record<string, null | string | number | boolean | bigint>;
 type Where = {
@@ -169,8 +175,9 @@ type CountResult<GenericResultWrapper> = OneResult<GenericResultWrapper, {
 declare class SelectBuilder<GenericResultWrapper, GenericResult = DefaultReturnObject> {
     _debugger: boolean;
     private _options;
-    private _queryBuilder;
-    constructor(options: Partial<SelectAll>, queryBuilder: (params: SelectAll) => QueryWithExtra<GenericResultWrapper>);
+    private _fetchAll;
+    private _fetchOne;
+    constructor(options: Partial<SelectAll>, fetchAll: (params: SelectAll) => QueryWithExtra<GenericResultWrapper>, fetchOne: (params: SelectOne) => QueryWithExtra<GenericResultWrapper>);
     setDebugger(state: boolean): void;
     tableName(tableName: SelectAll['tableName']): SelectBuilder<GenericResultWrapper, GenericResult>;
     fields(fields: SelectAll['fields']): SelectBuilder<GenericResultWrapper, GenericResult>;
@@ -182,14 +189,19 @@ declare class SelectBuilder<GenericResultWrapper, GenericResult = DefaultReturnO
     offset(offset: SelectAll['offset']): SelectBuilder<GenericResultWrapper, GenericResult>;
     limit(limit: SelectAll['limit']): SelectBuilder<GenericResultWrapper, GenericResult>;
     private _parseArray;
-    getQuery(): Query<ArrayResult<GenericResultWrapper, GenericResult>>;
+    getQueryAll(): Query<ArrayResult<GenericResultWrapper, GenericResult>>;
+    getQueryOne(): Query<OneResult<GenericResultWrapper, GenericResult>>;
     execute(): Promise<ArrayResult<GenericResultWrapper, GenericResult>>;
+    all(): Promise<ArrayResult<GenericResultWrapper, GenericResult>>;
+    one(): Promise<OneResult<GenericResultWrapper, GenericResult>>;
     count(): Promise<CountResult<GenericResultWrapper>>;
 }
 
 declare class QueryBuilder<GenericResultWrapper> {
-    _debugger: boolean;
+    protected options: QueryBuilderOptions;
+    constructor(options?: QueryBuilderOptions);
     setDebugger(state: boolean): void;
+    loggerWrapper(query: Query | Query[], innerFunction: () => any): Promise<any>;
     execute(query: Query): Promise<any>;
     batchExecute(queryArray: Query[]): Promise<any[]>;
     createTable<GenericResult = undefined>(params: {
@@ -233,39 +245,23 @@ declare class QueryBuilder<GenericResultWrapper> {
 
 declare class D1QB extends QueryBuilder<D1Result> {
     db: any;
-    constructor(db: any);
+    constructor(db: any, options?: QueryBuilderOptions);
     execute(query: Query): Promise<any>;
     batchExecute(queryArray: Query[]): Promise<any>;
 }
 
 declare class PGQB extends QueryBuilder<PGResult> {
     db: any;
-    constructor(db: any);
+    constructor(db: any, options?: QueryBuilderOptions);
     connect(): Promise<void>;
     close(): Promise<void>;
-    execute(query: Query): Promise<{
-        command: any;
-        lastRowId: any;
-        rowCount: any;
-        results: any;
-    } | {
-        command: any;
-        lastRowId: any;
-        rowCount: any;
-        results?: undefined;
-    }>;
+    execute(query: Query): Promise<any>;
 }
 
 declare class DOQB extends QueryBuilder<{}> {
-    db: SqlStorage;
-    constructor(db: SqlStorage);
-    execute(query: Query): Promise<{
-        results: Record<string, string | number | ArrayBuffer | null> | undefined;
-    } | {
-        results: Record<string, string | number | ArrayBuffer | null>[];
-    }>;
-}
-declare class DurableObjectDatabaseQB extends DOQB {
+    db: any;
+    constructor(db: any, options?: QueryBuilderOptions);
+    execute(query: Query): Promise<any>;
 }
 
-export { type ArrayResult, ConflictTypes, type ConflictUpsert, type CountResult, type D1Meta, D1QB, type D1Result, DOQB, type DefaultObject, type DefaultReturnObject, type Delete, type DeleteReturning, type DeleteWithoutReturning, DurableObjectDatabaseQB, FetchTypes, type Insert, type InsertMultiple, type InsertOne, type InsertWithoutReturning, type Join, JoinTypes, type OneResult, OrderTypes, PGQB, type PGResult, type Primitive, Query, QueryBuilder, QueryWithExtra, Raw, type RawQuery, type RawQueryFetchAll, type RawQueryFetchOne, type RawQueryWithoutFetching, type SelectAll, type SelectOne, type Update, type UpdateReturning, type UpdateWithoutReturning, type Where, type test };
+export { type ArrayResult, ConflictTypes, type ConflictUpsert, type CountResult, type D1Meta, D1QB, type D1Result, DOQB, type DefaultObject, type DefaultReturnObject, type Delete, type DeleteReturning, type DeleteWithoutReturning, FetchTypes, type Insert, type InsertMultiple, type InsertOne, type InsertWithoutReturning, type Join, JoinTypes, type OneResult, OrderTypes, PGQB, type PGResult, type Primitive, Query, QueryBuilder, type QueryBuilderOptions, type QueryLoggerMeta, QueryWithExtra, Raw, type RawQuery, type RawQueryFetchAll, type RawQueryFetchOne, type RawQueryWithoutFetching, type SelectAll, type SelectOne, type Update, type UpdateReturning, type UpdateWithoutReturning, type Where, type test, trimQuery };

package/dist/index.js

@@ -23,7 +23,6 @@ __export(src_exports, {
   ConflictTypes: () => ConflictTypes,
   D1QB: () => D1QB,
   DOQB: () => DOQB,
-  DurableObjectDatabaseQB: () => DurableObjectDatabaseQB,
   FetchTypes: () => FetchTypes,
   JoinTypes: () => JoinTypes,
   OrderTypes: () => OrderTypes,
@@ -31,7 +30,8 @@ __export(src_exports, {
   Query: () => Query,
   QueryBuilder: () => QueryBuilder,
   QueryWithExtra: () => QueryWithExtra,
-  Raw: () => Raw
+  Raw: () => Raw,
+  trimQuery: () => trimQuery
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -76,13 +76,20 @@ var Query = class {
   fetchType;
   constructor(executeMethod, query, args, fetchType) {
     this.executeMethod = executeMethod;
-    this.query = query;
+    this.query = trimQuery(query);
     this.arguments = args;
     this.fetchType = fetchType;
   }
   async execute() {
     return this.executeMethod(this);
   }
+  toObject() {
+    return {
+      query: this.query,
+      args: this.arguments,
+      fetchType: this.fetchType
+    };
+  }
 };
 var QueryWithExtra = class extends Query {
   countQuery;
@@ -96,15 +103,20 @@ var QueryWithExtra = class extends Query {
     );
   }
 };
+function trimQuery(query) {
+  return query.replace(/\s\s+/g, " ");
+}
 
 // src/modularBuilder.ts
 var SelectBuilder = class _SelectBuilder {
   _debugger = false;
   _options = {};
-  _queryBuilder;
-  constructor(options, queryBuilder) {
+  _fetchAll;
+  _fetchOne;
+  constructor(options, fetchAll, fetchOne) {
     this._options = options;
-    this._queryBuilder = queryBuilder;
+    this._fetchAll = fetchAll;
+    this._fetchOne = fetchOne;
   }
   setDebugger(state) {
     this._debugger = state;
@@ -115,7 +127,8 @@ var SelectBuilder = class _SelectBuilder {
         ...this._options,
         tableName
       },
-      this._queryBuilder
+      this._fetchAll,
+      this._fetchOne
     );
   }
   fields(fields) {
@@ -143,7 +156,8 @@ var SelectBuilder = class _SelectBuilder {
           params
         }
       },
-      this._queryBuilder
+      this._fetchAll,
+      this._fetchOne
     );
   }
   join(join) {
@@ -164,7 +178,8 @@ var SelectBuilder = class _SelectBuilder {
         ...this._options,
         offset
       },
-      this._queryBuilder
+      this._fetchAll,
+      this._fetchOne
     );
   }
   limit(limit) {
@@ -173,7 +188,8 @@ var SelectBuilder = class _SelectBuilder {
         ...this._options,
         limit
       },
-      this._queryBuilder
+      this._fetchAll,
+      this._fetchOne
     );
   }
   _parseArray(fieldName, option, value) {
@@ -191,25 +207,65 @@ var SelectBuilder = class _SelectBuilder {
         ...this._options,
         [fieldName]: val
       },
-      this._queryBuilder
+      this._fetchAll,
+      this._fetchOne
     );
   }
-  getQuery() {
-    return this._queryBuilder(this._options);
+  getQueryAll() {
+    return this._fetchAll(this._options);
+  }
+  getQueryOne() {
+    return this._fetchOne(this._options);
   }
   async execute() {
-    return this._queryBuilder(this._options).execute();
+    return this._fetchAll(this._options).execute();
+  }
+  async all() {
+    return this._fetchAll(this._options).execute();
+  }
+  async one() {
+    return this._fetchOne(this._options).execute();
   }
   async count() {
-    return this._queryBuilder(this._options).count();
+    return this._fetchOne(this._options).count();
   }
 };
 
 // src/builder.ts
 var QueryBuilder = class {
-  _debugger = false;
+  options;
+  constructor(options) {
+    this.options = options || {};
+  }
   setDebugger(state) {
-    this._debugger = state;
+    if (state === true) {
+      if (this.options.logger) {
+        return;
+      }
+      this.options.logger = (query, meta) => {
+        console.log(`[workers-qb][${meta.duration}ms] ${JSON.stringify(query)}`);
+      };
+    } else {
+      this.options.logger = void 0;
+    }
+  }
+  async loggerWrapper(query, innerFunction) {
+    const start = Date.now();
+    try {
+      return await innerFunction();
+    } catch (e) {
+      throw e;
+    } finally {
+      if (this.options.logger) {
+        if (Array.isArray(query)) {
+          for (const q of query) {
+            await this.options.logger(q.toObject(), { duration: Date.now() - start });
+          }
+        } else {
+          await this.options.logger(query.toObject(), { duration: Date.now() - start });
+        }
+      }
+    }
   }
   async execute(query) {
     throw new Error("Execute method not implemented");
@@ -238,6 +294,9 @@ var QueryBuilder = class {
       },
       (params) => {
         return this.fetchAll(params);
+      },
+      (params) => {
+        return this.fetchOne(params);
       }
     );
   }
@@ -507,84 +566,74 @@ var QueryBuilder = class {
 // src/databases/d1.ts
 var D1QB = class extends QueryBuilder {
   db;
-  constructor(db) {
-    super();
+  constructor(db, options) {
+    super(options);
     this.db = db;
   }
   async execute(query) {
-    let stmt = this.db.prepare(query.query);
-    if (this._debugger) {
-      console.log({
-        "workers-qb": {
-          query: query.query,
-          arguments: query.arguments,
-          fetchType: query.fetchType
-        }
-      });
-    }
-    if (query.arguments) {
-      stmt = stmt.bind(...query.arguments);
-    }
-    if (query.fetchType === "ONE" /* ONE */ || query.fetchType === "ALL" /* ALL */) {
-      const resp = await stmt.all();
-      return {
-        changes: resp.meta?.changes,
-        duration: resp.meta?.duration,
-        last_row_id: resp.meta?.last_row_id,
-        served_by: resp.meta?.served_by,
-        meta: resp.meta,
-        success: resp.success,
-        results: query.fetchType === "ONE" /* ONE */ ? resp.results[0] : resp.results
-      };
-    }
-    return stmt.run();
-  }
-  async batchExecute(queryArray) {
-    if (this._debugger) {
-      console.log({
-        "workers-qb": queryArray
-      });
-    }
-    const statements = queryArray.map((query) => {
+    return await this.loggerWrapper(query, async () => {
       let stmt = this.db.prepare(query.query);
       if (query.arguments) {
         stmt = stmt.bind(...query.arguments);
       }
-      return stmt;
+      if (query.fetchType === "ONE" /* ONE */ || query.fetchType === "ALL" /* ALL */) {
+        const resp = await stmt.all();
+        return {
+          changes: resp.meta?.changes,
+          duration: resp.meta?.duration,
+          last_row_id: resp.meta?.last_row_id,
+          served_by: resp.meta?.served_by,
+          meta: resp.meta,
+          success: resp.success,
+          results: query.fetchType === "ONE" /* ONE */ ? resp.results[0] : resp.results
+        };
+      }
+      return stmt.run();
     });
-    const responses = await this.db.batch(statements);
-    return responses.map(
-      (resp, i) => {
-        if (queryArray && queryArray[i] !== void 0 && queryArray[i]?.fetchType) {
-          return {
-            changes: resp.meta?.changes,
-            duration: resp.meta?.duration,
-            last_row_id: resp.meta?.last_row_id,
-            served_by: resp.meta?.served_by,
-            meta: resp.meta,
-            success: resp.success,
-            results: queryArray[i]?.fetchType === "ONE" /* ONE */ ? resp.results?.[0] : resp.results
-          };
-        } else {
-          return {
-            changes: resp.meta?.changes,
-            duration: resp.meta?.duration,
-            last_row_id: resp.meta?.last_row_id,
-            served_by: resp.meta?.served_by,
-            meta: resp.meta,
-            success: resp.success
-          };
+  }
+  async batchExecute(queryArray) {
+    return await this.loggerWrapper(queryArray, async () => {
+      const statements = queryArray.map((query) => {
+        let stmt = this.db.prepare(query.query);
+        if (query.arguments) {
+          stmt = stmt.bind(...query.arguments);
         }
-      }
-    );
+        return stmt;
+      });
+      const responses = await this.db.batch(statements);
+      return responses.map(
+        (resp, i) => {
+          if (queryArray && queryArray[i] !== void 0 && queryArray[i]?.fetchType) {
+            return {
+              changes: resp.meta?.changes,
+              duration: resp.meta?.duration,
+              last_row_id: resp.meta?.last_row_id,
+              served_by: resp.meta?.served_by,
+              meta: resp.meta,
+              success: resp.success,
+              results: queryArray[i]?.fetchType === "ONE" /* ONE */ ? resp.results?.[0] : resp.results
+            };
+          } else {
+            return {
+              changes: resp.meta?.changes,
+              duration: resp.meta?.duration,
+              last_row_id: resp.meta?.last_row_id,
+              served_by: resp.meta?.served_by,
+              meta: resp.meta,
+              success: resp.success
+            };
+          }
+        }
+      );
+    });
   }
 };
 
 // src/databases/pg.ts
 var PGQB = class extends QueryBuilder {
   db;
-  constructor(db) {
-    super();
+  constructor(db, options) {
+    super(options);
     this.db = db;
   }
   async connect() {
@@ -594,87 +643,74 @@ var PGQB = class extends QueryBuilder {
     await this.db.end();
   }
   async execute(query) {
-    const queryString = query.query.replaceAll("?", "$");
-    if (this._debugger) {
-      console.log({
-        "workers-qb": query
-      });
-    }
-    let result;
-    if (query.arguments) {
-      result = await this.db.query({
-        values: query.arguments,
-        text: queryString
-      });
-    } else {
-      result = await this.db.query({
-        text: queryString
-      });
-    }
-    if (query.fetchType === "ONE" /* ONE */ || query.fetchType === "ALL" /* ALL */) {
+    return await this.loggerWrapper(query, async () => {
+      const queryString = query.query.replaceAll("?", "$");
+      let result;
+      if (query.arguments) {
+        result = await this.db.query({
+          values: query.arguments,
+          text: queryString
+        });
+      } else {
+        result = await this.db.query({
+          text: queryString
+        });
+      }
+      if (query.fetchType === "ONE" /* ONE */ || query.fetchType === "ALL" /* ALL */) {
+        return {
+          command: result.command,
+          lastRowId: result.oid,
+          rowCount: result.rowCount,
+          results: query.fetchType === "ONE" /* ONE */ ? result.rows[0] : result.rows
+        };
+      }
       return {
         command: result.command,
         lastRowId: result.oid,
-        rowCount: result.rowCount,
-        results: query.fetchType === "ONE" /* ONE */ ? result.rows[0] : result.rows
+        rowCount: result.rowCount
       };
-    }
-    return {
-      command: result.command,
-      lastRowId: result.oid,
-      rowCount: result.rowCount
-    };
+    });
   }
 };
 
 // src/databases/do.ts
 var DOQB = class extends QueryBuilder {
   db;
-  constructor(db) {
-    super();
+  constructor(db, options) {
+    super(options);
     this.db = db;
   }
   async execute(query) {
-    if (this._debugger) {
-      console.log({
-        "workers-qb": {
-          query: query.query,
-          arguments: query.arguments,
-          fetchType: query.fetchType
+    return await this.loggerWrapper(query, async () => {
+      if (query.arguments) {
+        let stmt = this.db.prepare(query.query);
+        const result = stmt(...query.arguments);
+        if (query.fetchType == "ONE" /* ONE */) {
+          return {
+            results: Array.from(result)[0]
+          };
         }
-      });
-    }
-    if (query.arguments) {
-      let stmt = this.db.prepare(query.query);
-      const result = stmt(...query.arguments);
+        return {
+          results: Array.from(result)
+        };
+      }
+      const cursor = this.db.exec(query.query);
       if (query.fetchType == "ONE" /* ONE */) {
         return {
-          results: Array.from(result)[0]
+          results: Array.from(cursor)[0]
         };
       }
       return {
-        results: Array.from(result)
-      };
-    }
-    const cursor = this.db.exec(query.query);
-    if (query.fetchType == "ONE" /* ONE */) {
-      return {
-        results: Array.from(cursor)[0]
+        results: Array.from(cursor)
       };
-    }
-    return {
-      results: Array.from(cursor)
-    };
+    });
   }
 };
-var DurableObjectDatabaseQB = class extends DOQB {
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ConflictTypes,
   D1QB,
   DOQB,
-  DurableObjectDatabaseQB,
   FetchTypes,
   JoinTypes,
   OrderTypes,
@@ -682,5 +718,6 @@ var DurableObjectDatabaseQB = class extends DOQB {
   Query,
   QueryBuilder,
   QueryWithExtra,
-  Raw
+  Raw,
+  trimQuery
 });

package/dist/index.mjs

@@ -39,13 +39,20 @@ var Query = class {
   fetchType;
   constructor(executeMethod, query, args, fetchType) {
     this.executeMethod = executeMethod;
-    this.query = query;
+    this.query = trimQuery(query);
     this.arguments = args;
     this.fetchType = fetchType;
   }
   async execute() {
     return this.executeMethod(this);
   }
+  toObject() {
+    return {
+      query: this.query,
+      args: this.arguments,
+      fetchType: this.fetchType
+    };
+  }
 };
 var QueryWithExtra = class extends Query {
   countQuery;
@@ -59,15 +66,20 @@ var QueryWithExtra = class extends Query {
     );
   }
 };
+function trimQuery(query) {
+  return query.replace(/\s\s+/g, " ");
+}
 
 // src/modularBuilder.ts
 var SelectBuilder = class _SelectBuilder {
   _debugger = false;
   _options = {};
-  _queryBuilder;
-  constructor(options, queryBuilder) {
+  _fetchAll;
+  _fetchOne;
+  constructor(options, fetchAll, fetchOne) {
     this._options = options;
-    this._queryBuilder = queryBuilder;
+    this._fetchAll = fetchAll;
+    this._fetchOne = fetchOne;
   }
   setDebugger(state) {
     this._debugger = state;
@@ -78,7 +90,8 @@ var SelectBuilder = class _SelectBuilder {
         ...this._options,
         tableName
       },
-      this._queryBuilder
+      this._fetchAll,
+      this._fetchOne
     );
   }
   fields(fields) {
@@ -106,7 +119,8 @@ var SelectBuilder = class _SelectBuilder {
           params
         }
       },
-      this._queryBuilder
+      this._fetchAll,
+      this._fetchOne
     );
   }
   join(join) {
@@ -127,7 +141,8 @@ var SelectBuilder = class _SelectBuilder {
         ...this._options,
         offset
       },
-      this._queryBuilder
+      this._fetchAll,
+      this._fetchOne
     );
   }
   limit(limit) {
@@ -136,7 +151,8 @@ var SelectBuilder = class _SelectBuilder {
         ...this._options,
         limit
       },
-      this._queryBuilder
+      this._fetchAll,
+      this._fetchOne
     );
   }
   _parseArray(fieldName, option, value) {
@@ -154,25 +170,65 @@ var SelectBuilder = class _SelectBuilder {
         ...this._options,
         [fieldName]: val
       },
-      this._queryBuilder
+      this._fetchAll,
+      this._fetchOne
     );
   }
-  getQuery() {
-    return this._queryBuilder(this._options);
+  getQueryAll() {
+    return this._fetchAll(this._options);
+  }
+  getQueryOne() {
+    return this._fetchOne(this._options);
   }
   async execute() {
-    return this._queryBuilder(this._options).execute();
+    return this._fetchAll(this._options).execute();
+  }
+  async all() {
+    return this._fetchAll(this._options).execute();
+  }
+  async one() {
+    return this._fetchOne(this._options).execute();
   }
   async count() {
-    return this._queryBuilder(this._options).count();
+    return this._fetchOne(this._options).count();
   }
 };
 
 // src/builder.ts
 var QueryBuilder = class {
-  _debugger = false;
+  options;
+  constructor(options) {
+    this.options = options || {};
+  }
   setDebugger(state) {
-    this._debugger = state;
+    if (state === true) {
+      if (this.options.logger) {
+        return;
+      }
+      this.options.logger = (query, meta) => {
+        console.log(`[workers-qb][${meta.duration}ms] ${JSON.stringify(query)}`);
+      };
+    } else {
+      this.options.logger = void 0;
+    }
+  }
+  async loggerWrapper(query, innerFunction) {
+    const start = Date.now();
+    try {
+      return await innerFunction();
+    } catch (e) {
+      throw e;
+    } finally {
+      if (this.options.logger) {
+        if (Array.isArray(query)) {
+          for (const q of query) {
+            await this.options.logger(q.toObject(), { duration: Date.now() - start });
+          }
+        } else {
+          await this.options.logger(query.toObject(), { duration: Date.now() - start });
+        }
+      }
+    }
   }
   async execute(query) {
     throw new Error("Execute method not implemented");
@@ -201,6 +257,9 @@ var QueryBuilder = class {
       },
       (params) => {
         return this.fetchAll(params);
+      },
+      (params) => {
+        return this.fetchOne(params);
       }
     );
   }
@@ -470,84 +529,74 @@ var QueryBuilder = class {
 // src/databases/d1.ts
 var D1QB = class extends QueryBuilder {
   db;
-  constructor(db) {
-    super();
+  constructor(db, options) {
+    super(options);
     this.db = db;
   }
   async execute(query) {
-    let stmt = this.db.prepare(query.query);
-    if (this._debugger) {
-      console.log({
-        "workers-qb": {
-          query: query.query,
-          arguments: query.arguments,
-          fetchType: query.fetchType
-        }
-      });
-    }
-    if (query.arguments) {
-      stmt = stmt.bind(...query.arguments);
-    }
-    if (query.fetchType === "ONE" /* ONE */ || query.fetchType === "ALL" /* ALL */) {
-      const resp = await stmt.all();
-      return {
-        changes: resp.meta?.changes,
-        duration: resp.meta?.duration,
-        last_row_id: resp.meta?.last_row_id,
-        served_by: resp.meta?.served_by,
-        meta: resp.meta,
-        success: resp.success,
-        results: query.fetchType === "ONE" /* ONE */ ? resp.results[0] : resp.results
-      };
-    }
-    return stmt.run();
-  }
-  async batchExecute(queryArray) {
-    if (this._debugger) {
-      console.log({
-        "workers-qb": queryArray
-      });
-    }
-    const statements = queryArray.map((query) => {
+    return await this.loggerWrapper(query, async () => {
       let stmt = this.db.prepare(query.query);
       if (query.arguments) {
         stmt = stmt.bind(...query.arguments);
       }
-      return stmt;
+      if (query.fetchType === "ONE" /* ONE */ || query.fetchType === "ALL" /* ALL */) {
+        const resp = await stmt.all();
+        return {
+          changes: resp.meta?.changes,
+          duration: resp.meta?.duration,
+          last_row_id: resp.meta?.last_row_id,
+          served_by: resp.meta?.served_by,
+          meta: resp.meta,
+          success: resp.success,
+          results: query.fetchType === "ONE" /* ONE */ ? resp.results[0] : resp.results
+        };
+      }
+      return stmt.run();
     });
-    const responses = await this.db.batch(statements);
-    return responses.map(
-      (resp, i) => {
-        if (queryArray && queryArray[i] !== void 0 && queryArray[i]?.fetchType) {
-          return {
-            changes: resp.meta?.changes,
-            duration: resp.meta?.duration,
-            last_row_id: resp.meta?.last_row_id,
-            served_by: resp.meta?.served_by,
-            meta: resp.meta,
-            success: resp.success,
-            results: queryArray[i]?.fetchType === "ONE" /* ONE */ ? resp.results?.[0] : resp.results
-          };
-        } else {
-          return {
-            changes: resp.meta?.changes,
-            duration: resp.meta?.duration,
-            last_row_id: resp.meta?.last_row_id,
-            served_by: resp.meta?.served_by,
-            meta: resp.meta,
-            success: resp.success
-          };
+  }
+  async batchExecute(queryArray) {
+    return await this.loggerWrapper(queryArray, async () => {
+      const statements = queryArray.map((query) => {
+        let stmt = this.db.prepare(query.query);
+        if (query.arguments) {
+          stmt = stmt.bind(...query.arguments);
         }
-      }
-    );
+        return stmt;
+      });
+      const responses = await this.db.batch(statements);
+      return responses.map(
+        (resp, i) => {
+          if (queryArray && queryArray[i] !== void 0 && queryArray[i]?.fetchType) {
+            return {
+              changes: resp.meta?.changes,
+              duration: resp.meta?.duration,
+              last_row_id: resp.meta?.last_row_id,
+              served_by: resp.meta?.served_by,
+              meta: resp.meta,
+              success: resp.success,
+              results: queryArray[i]?.fetchType === "ONE" /* ONE */ ? resp.results?.[0] : resp.results
+            };
+          } else {
+            return {
+              changes: resp.meta?.changes,
+              duration: resp.meta?.duration,
+              last_row_id: resp.meta?.last_row_id,
+              served_by: resp.meta?.served_by,
+              meta: resp.meta,
+              success: resp.success
+            };
+          }
+        }
+      );
+    });
   }
 };
 
 // src/databases/pg.ts
 var PGQB = class extends QueryBuilder {
   db;
-  constructor(db) {
-    super();
+  constructor(db, options) {
+    super(options);
     this.db = db;
   }
   async connect() {
@@ -557,86 +606,73 @@ var PGQB = class extends QueryBuilder {
     await this.db.end();
   }
   async execute(query) {
-    const queryString = query.query.replaceAll("?", "$");
-    if (this._debugger) {
-      console.log({
-        "workers-qb": query
-      });
-    }
-    let result;
-    if (query.arguments) {
-      result = await this.db.query({
-        values: query.arguments,
-        text: queryString
-      });
-    } else {
-      result = await this.db.query({
-        text: queryString
-      });
-    }
-    if (query.fetchType === "ONE" /* ONE */ || query.fetchType === "ALL" /* ALL */) {
+    return await this.loggerWrapper(query, async () => {
+      const queryString = query.query.replaceAll("?", "$");
+      let result;
+      if (query.arguments) {
+        result = await this.db.query({
+          values: query.arguments,
+          text: queryString
+        });
+      } else {
+        result = await this.db.query({
+          text: queryString
+        });
+      }
+      if (query.fetchType === "ONE" /* ONE */ || query.fetchType === "ALL" /* ALL */) {
+        return {
+          command: result.command,
+          lastRowId: result.oid,
+          rowCount: result.rowCount,
+          results: query.fetchType === "ONE" /* ONE */ ? result.rows[0] : result.rows
+        };
+      }
       return {
         command: result.command,
         lastRowId: result.oid,
-        rowCount: result.rowCount,
-        results: query.fetchType === "ONE" /* ONE */ ? result.rows[0] : result.rows
+        rowCount: result.rowCount
       };
-    }
-    return {
-      command: result.command,
-      lastRowId: result.oid,
-      rowCount: result.rowCount
-    };
+    });
   }
 };
 
 // src/databases/do.ts
 var DOQB = class extends QueryBuilder {
   db;
-  constructor(db) {
-    super();
+  constructor(db, options) {
+    super(options);
     this.db = db;
   }
   async execute(query) {
-    if (this._debugger) {
-      console.log({
-        "workers-qb": {
-          query: query.query,
-          arguments: query.arguments,
-          fetchType: query.fetchType
+    return await this.loggerWrapper(query, async () => {
+      if (query.arguments) {
+        let stmt = this.db.prepare(query.query);
+        const result = stmt(...query.arguments);
+        if (query.fetchType == "ONE" /* ONE */) {
+          return {
+            results: Array.from(result)[0]
+          };
         }
-      });
-    }
-    if (query.arguments) {
-      let stmt = this.db.prepare(query.query);
-      const result = stmt(...query.arguments);
+        return {
+          results: Array.from(result)
+        };
+      }
+      const cursor = this.db.exec(query.query);
       if (query.fetchType == "ONE" /* ONE */) {
         return {
-          results: Array.from(result)[0]
+          results: Array.from(cursor)[0]
         };
       }
       return {
-        results: Array.from(result)
-      };
-    }
-    const cursor = this.db.exec(query.query);
-    if (query.fetchType == "ONE" /* ONE */) {
-      return {
-        results: Array.from(cursor)[0]
+        results: Array.from(cursor)
       };
-    }
-    return {
-      results: Array.from(cursor)
-    };
+    });
   }
 };
-var DurableObjectDatabaseQB = class extends DOQB {
-};
 export {
   ConflictTypes,
   D1QB,
   DOQB,
-  DurableObjectDatabaseQB,
   FetchTypes,
   JoinTypes,
   OrderTypes,
@@ -644,5 +680,6 @@ export {
   Query,
   QueryBuilder,
   QueryWithExtra,
-  Raw
+  Raw,
+  trimQuery
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "workers-qb",
-  "version": "1.4.3",
+  "version": "1.5.1",
   "description": "Zero dependencies Query Builder for Cloudflare Workers",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",