workers-qb 1.11.1 → 1.12.0

package/dist/index.d.ts

@@ -19,6 +19,73 @@ declare enum JoinTypes {
     CROSS = "CROSS"
 }
 
+/**
+ * Schema-aware type utilities for type-safe query building.
+ *
+ * Define your database schema as a type and pass it to the query builder
+ * to get autocomplete for table names, column names, and inferred result types.
+ *
+ * @example
+ * ```typescript
+ * type Schema = {
+ *   users: {
+ *     id: number
+ *     name: string
+ *     email: string
+ *   }
+ *   posts: {
+ *     id: number
+ *     user_id: number
+ *     title: string
+ *   }
+ * }
+ *
+ * const qb = new D1QB<Schema>(env.DB)
+ *
+ * // Now get autocomplete for tableName, fields, orderBy, etc.
+ * const users = await qb.fetchAll({
+ *   tableName: 'users',      // autocomplete: 'users' | 'posts'
+ *   fields: ['id', 'name'],  // autocomplete: 'id' | 'name' | 'email'
+ * }).execute()
+ * ```
+ */
+/**
+ * Base type for database schemas.
+ * A schema is a record of table names to their column types.
+ */
+type TableSchema = Record<string, Record<string, unknown>>;
+/**
+ * Extract table names from a schema.
+ */
+type TableName<S extends TableSchema> = keyof S & string;
+/**
+ * Extract column names for a specific table.
+ */
+type ColumnName<S extends TableSchema, T extends TableName<S>> = keyof S[T] & string;
+/**
+ * Pick specific columns from a table's type.
+ */
+type SelectColumns<S extends TableSchema, T extends TableName<S>, F extends ColumnName<S, T>> = Pick<S[T], F>;
+/**
+ * Type for INSERT data - all columns are optional to allow partial inserts.
+ * In practice, required columns will be enforced by the database.
+ */
+type InsertData<S extends TableSchema, T extends TableName<S>> = Partial<S[T]>;
+/**
+ * Type for UPDATE data - all columns are optional.
+ */
+type UpdateData<S extends TableSchema, T extends TableName<S>> = Partial<S[T]>;
+/**
+ * Helper to check if a schema is empty (for backwards compatibility).
+ * When Schema = {}, we fall back to loose types.
+ */
+type IsEmptySchema<S extends TableSchema> = keyof S extends never ? true : false;
+/**
+ * Conditional type that returns strict types when schema is provided,
+ * or loose types when schema is empty.
+ */
+type SchemaAware<S extends TableSchema, Strict, Loose> = IsEmptySchema<S> extends true ? Loose : Strict;
+
 declare class Raw {
     isRaw: boolean;
     content: any;
@@ -43,24 +110,24 @@ declare function trimQuery(query: string): string;
 interface SelectExecuteOptions {
     lazy?: boolean;
 }
-declare class SelectBuilder<GenericResultWrapper, GenericResult = DefaultReturnObject, IsAsync extends boolean = true> {
+declare class SelectBuilder<Schema extends TableSchema = {}, GenericResultWrapper = unknown, GenericResult = DefaultReturnObject, IsAsync extends boolean = true> {
     _debugger: boolean;
     _options: Partial<SelectAll>;
     _fetchAll: (params: SelectAll) => QueryWithExtra<GenericResultWrapper, any, IsAsync>;
     _fetchOne: (params: SelectOne) => QueryWithExtra<GenericResultWrapper, any, IsAsync>;
     constructor(options: Partial<SelectAll>, fetchAll: (params: SelectAll) => QueryWithExtra<GenericResultWrapper, any, IsAsync>, fetchOne: (params: SelectOne) => QueryWithExtra<GenericResultWrapper, any, IsAsync>);
     setDebugger(state: boolean): void;
-    tableName(tableName: SelectAll['tableName']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
-    fields(fields: SelectAll['fields']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
-    where(conditions: string | Array<string>, params?: Primitive | Primitive[]): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
-    whereIn<T extends string | Array<string>, P extends T extends Array<string> ? Primitive[][] : Primitive[]>(fields: T, values: P): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
-    join(join: SelectAll['join']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
-    groupBy(groupBy: SelectAll['groupBy']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
-    having(conditions: string | Array<string>, params?: Primitive | Primitive[]): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
-    orderBy(orderBy: SelectAll['orderBy']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
-    offset(offset: SelectAll['offset']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
-    limit(limit: SelectAll['limit']): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
-    _parseArray(fieldName: string, option: any, value: any): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
+    tableName(tableName: SelectAll['tableName']): SelectBuilder<Schema, GenericResultWrapper, GenericResult, IsAsync>;
+    fields(fields: SelectAll['fields']): SelectBuilder<Schema, GenericResultWrapper, GenericResult, IsAsync>;
+    where(conditions: string | Array<string>, params?: Primitive | Primitive[]): SelectBuilder<Schema, GenericResultWrapper, GenericResult, IsAsync>;
+    whereIn<T extends string | Array<string>, P extends T extends Array<string> ? Primitive[][] : Primitive[]>(fields: T, values: P): SelectBuilder<Schema, GenericResultWrapper, GenericResult, IsAsync>;
+    join(join: SelectAll['join']): SelectBuilder<Schema, GenericResultWrapper, GenericResult, IsAsync>;
+    groupBy(groupBy: SelectAll['groupBy']): SelectBuilder<Schema, GenericResultWrapper, GenericResult, IsAsync>;
+    having(conditions: string | Array<string>, params?: Primitive | Primitive[]): SelectBuilder<Schema, GenericResultWrapper, GenericResult, IsAsync>;
+    orderBy(orderBy: SelectAll['orderBy']): SelectBuilder<Schema, GenericResultWrapper, GenericResult, IsAsync>;
+    offset(offset: SelectAll['offset']): SelectBuilder<Schema, GenericResultWrapper, GenericResult, IsAsync>;
+    limit(limit: SelectAll['limit']): SelectBuilder<Schema, GenericResultWrapper, GenericResult, IsAsync>;
+    _parseArray(fieldName: string, option: any, value: any): SelectBuilder<Schema, GenericResultWrapper, GenericResult, IsAsync>;
     getQueryAll<P extends SelectExecuteOptions = SelectExecuteOptions>(options?: P): Query<ArrayResult<GenericResultWrapper, GenericResult, IsAsync, P extends {
         lazy: true;
     } ? true : false>, IsAsync>;
@@ -90,7 +157,7 @@ type SimpleMerge<Destination, Source> = {
 } & Source;
 type Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
 
-type Primitive = null | string | number | boolean | bigint | Raw | SelectAll | SelectBuilder<any, any, any>;
+type Primitive = null | string | number | boolean | bigint | ArrayBuffer | Raw | SelectAll | SelectBuilder<any, any, any>;
 type QueryLoggerMeta = {
     duration?: number;
 };
@@ -98,7 +165,7 @@ type QueryBuilderOptions<IsAsync extends boolean = true> = {
     logger?: (query: RawQuery, meta: QueryLoggerMeta) => MaybeAsync<IsAsync, void>;
 };
 type DefaultObject = Record<string, Primitive>;
-type DefaultReturnObject = Record<string, null | string | number | boolean | bigint>;
+type DefaultReturnObject = Record<string, null | string | number | boolean | bigint | ArrayBuffer>;
 type Where = {
     conditions: string | Array<string>;
     params?: Primitive | Primitive[];
@@ -157,7 +224,6 @@ type InsertMultiple = Omit<Insert, 'data' | 'returning'> & {
     returning: string | Array<string>;
 };
 type InsertWithoutReturning = Omit<Insert, 'returning'>;
-type test<I extends Insert = Insert> = I;
 type Update = {
     tableName: string;
     data: DefaultObject;
@@ -230,12 +296,69 @@ type CountResult<GenericResultWrapper> = OneResult<GenericResultWrapper, {
 type AsyncType<T> = Promise<T>;
 type SyncType<T> = T;
 type MaybeAsync<IsAsync extends boolean, T> = IsAsync extends true ? AsyncType<T> : SyncType<T>;
+/**
+ * Schema-aware SELECT parameters.
+ * When a schema is provided, tableName and fields get autocomplete.
+ */
+type TypedSelectOne<S extends TableSchema, T extends TableName<S>, F extends ColumnName<S, T> = ColumnName<S, T>> = {
+    tableName: T;
+    fields?: F[] | F | '*';
+    where?: Where;
+    join?: Join | Array<Join>;
+    groupBy?: ColumnName<S, T> | ColumnName<S, T>[] | string | string[];
+    having?: Where;
+    orderBy?: Partial<Record<ColumnName<S, T>, OrderTypes | string>> | string | string[];
+    offset?: number;
+};
+/**
+ * Schema-aware SELECT ALL parameters (includes limit and lazy).
+ */
+type TypedSelectAll<S extends TableSchema, T extends TableName<S>, F extends ColumnName<S, T> = ColumnName<S, T>> = TypedSelectOne<S, T, F> & {
+    limit?: number;
+    lazy?: boolean;
+};
+/**
+ * Schema-aware INSERT parameters.
+ */
+type TypedInsert<S extends TableSchema, T extends TableName<S>> = {
+    tableName: T;
+    data: Partial<S[T]> | Array<Partial<S[T]>>;
+    returning?: ColumnName<S, T>[] | ColumnName<S, T> | '*';
+    onConflict?: string | ConflictTypes | ConflictUpsert;
+};
+/**
+ * Schema-aware UPDATE parameters.
+ */
+type TypedUpdate<S extends TableSchema, T extends TableName<S>> = {
+    tableName: T;
+    data: Partial<S[T]>;
+    where?: Where;
+    returning?: ColumnName<S, T>[] | ColumnName<S, T> | '*';
+    onConflict?: string | ConflictTypes;
+};
+/**
+ * Schema-aware DELETE parameters.
+ */
+type TypedDelete<S extends TableSchema, T extends TableName<S>> = {
+    tableName: T;
+    where: Where;
+    returning?: ColumnName<S, T>[] | ColumnName<S, T> | '*';
+    orderBy?: Partial<Record<ColumnName<S, T>, OrderTypes | string>> | string | string[];
+    limit?: number;
+    offset?: number;
+};
+/**
+ * Infer the result type based on selected fields.
+ * If fields is '*' or undefined, returns full table type.
+ * If fields is an array, returns Pick of those fields.
+ */
+type InferResult<S extends TableSchema, T extends TableName<S>, F> = F extends '*' ? S[T] : F extends ColumnName<S, T>[] ? Pick<S[T], F[number]> : F extends ColumnName<S, T> ? Pick<S[T], F> : S[T];
 
 declare function defaultLogger(query: RawQuery, meta: QueryLoggerMeta): any;
 declare function asyncLoggerWrapper<Async extends boolean = true>(query: Query<any, Async> | Query<any, Async>[], loggerFunction: CallableFunction | undefined, innerFunction: () => any): Promise<any>;
 declare function syncLoggerWrapper<Async extends boolean = false>(query: Query<any, Async> | Query<any, Async>[], loggerFunction: CallableFunction | undefined, innerFunction: () => any): any;
 
-declare class QueryBuilder<GenericResultWrapper, IsAsync extends boolean = true> {
+declare class QueryBuilder<Schema extends TableSchema = {}, GenericResultWrapper = unknown, IsAsync extends boolean = true> {
     protected options: QueryBuilderOptions<IsAsync>;
     loggerWrapper: typeof asyncLoggerWrapper;
     constructor(options?: QueryBuilderOptions<IsAsync>);
@@ -252,19 +375,27 @@ declare class QueryBuilder<GenericResultWrapper, IsAsync extends boolean = true>
         tableName: string;
         ifExists?: boolean;
     }): Query<ArrayResult<GenericResultWrapper, GenericResult, IsAsync>, IsAsync>;
-    select<GenericResult = DefaultReturnObject>(tableName: string): SelectBuilder<GenericResultWrapper, GenericResult, IsAsync>;
+    select<T extends TableName<Schema>>(tableName: T): SelectBuilder<Schema, GenericResultWrapper, Schema[T], IsAsync>;
+    select<GenericResult = DefaultReturnObject>(tableName: string): SelectBuilder<{}, GenericResultWrapper, GenericResult, IsAsync>;
+    fetchOne<T extends TableName<Schema>, F extends ColumnName<Schema, T> = ColumnName<Schema, T>>(params: TypedSelectOne<Schema, T, F>): QueryWithExtra<GenericResultWrapper, OneResult<GenericResultWrapper, InferResult<Schema, T, F[] | undefined>>, IsAsync>;
     fetchOne<GenericResult = DefaultReturnObject>(params: SelectOne): QueryWithExtra<GenericResultWrapper, OneResult<GenericResultWrapper, GenericResult>, IsAsync>;
+    fetchAll<T extends TableName<Schema>, F extends ColumnName<Schema, T> = ColumnName<Schema, T>, P extends TypedSelectAll<Schema, T, F> = TypedSelectAll<Schema, T, F>>(params: P): QueryWithExtra<GenericResultWrapper, ArrayResult<GenericResultWrapper, InferResult<Schema, T, F[] | undefined>, IsAsync, P extends {
+        lazy: true;
+    } ? true : false>, IsAsync>;
     fetchAll<GenericResult = DefaultReturnObject, P extends SelectAll = SelectAll>(params: P): QueryWithExtra<GenericResultWrapper, ArrayResult<GenericResultWrapper, GenericResult, IsAsync, P extends {
         lazy: true;
     } ? true : false>, IsAsync>;
     raw<GenericResult = DefaultReturnObject>(params: RawQueryFetchOne): Query<OneResult<GenericResultWrapper, GenericResult>, IsAsync>;
     raw<GenericResult = DefaultReturnObject>(params: RawQueryFetchAll): Query<ArrayResult<GenericResultWrapper, GenericResult, IsAsync>, IsAsync>;
     raw<GenericResult = DefaultReturnObject>(params: RawQueryWithoutFetching): Query<GenericResultWrapper, IsAsync>;
+    insert<T extends TableName<Schema>>(params: TypedInsert<Schema, T>): Query<GenericResultWrapper, IsAsync>;
     insert<GenericResult = DefaultReturnObject>(params: InsertOne): Query<OneResult<GenericResultWrapper, GenericResult>, IsAsync>;
     insert<GenericResult = DefaultReturnObject>(params: InsertMultiple): Query<ArrayResult<GenericResultWrapper, GenericResult, IsAsync>, IsAsync>;
     insert<GenericResult = DefaultReturnObject>(params: InsertWithoutReturning): Query<GenericResultWrapper, IsAsync>;
+    update<T extends TableName<Schema>>(params: TypedUpdate<Schema, T>): Query<GenericResultWrapper, IsAsync>;
     update<GenericResult = DefaultReturnObject>(params: UpdateReturning): Query<ArrayResult<GenericResultWrapper, GenericResult, IsAsync>, IsAsync>;
     update<GenericResult = DefaultReturnObject>(params: UpdateWithoutReturning): Query<GenericResultWrapper, IsAsync>;
+    delete<T extends TableName<Schema>>(params: TypedDelete<Schema, T>): Query<GenericResultWrapper, IsAsync>;
     delete<GenericResult = DefaultReturnObject>(params: DeleteReturning): Query<ArrayResult<GenericResultWrapper, GenericResult, IsAsync>, IsAsync>;
     delete<GenericResult = DefaultReturnObject>(params: DeleteWithoutReturning): Query<GenericResultWrapper, IsAsync>;
     protected _parse_arguments(row: DefaultObject): Array<any>;
@@ -311,20 +442,20 @@ type MigrationOptions = {
     tableName?: string;
 };
 declare class syncMigrationsBuilder<GenericResultWrapper> {
-    _builder: QueryBuilder<GenericResultWrapper, false>;
+    _builder: QueryBuilder<any, GenericResultWrapper, false>;
     _migrations: Array<Migration>;
     _tableName: string;
-    constructor(options: MigrationOptions, builder: QueryBuilder<GenericResultWrapper, false>);
+    constructor(options: MigrationOptions, builder: QueryBuilder<any, GenericResultWrapper, false>);
     initialize(): void;
     getApplied(): Array<MigrationEntry>;
     getUnapplied(): Array<Migration>;
     apply(): Array<Migration>;
 }
 declare class asyncMigrationsBuilder<GenericResultWrapper> {
-    _builder: QueryBuilder<GenericResultWrapper, true>;
+    _builder: QueryBuilder<any, GenericResultWrapper, true>;
     _migrations: Array<Migration>;
     _tableName: string;
-    constructor(options: MigrationOptions, builder: QueryBuilder<GenericResultWrapper, true>);
+    constructor(options: MigrationOptions, builder: QueryBuilder<any, GenericResultWrapper, true>);
     initialize(): Promise<void>;
     getApplied(): Promise<Array<MigrationEntry>>;
     getUnapplied(): Promise<Array<Migration>>;
@@ -336,7 +467,7 @@ interface D1Database {
     batch: any;
     exec: any;
 }
-declare class D1QB extends QueryBuilder<D1Result> {
+declare class D1QB<Schema extends TableSchema = {}> extends QueryBuilder<Schema, D1Result, true> {
     db: any;
     constructor(db: D1Database, options?: QueryBuilderOptions);
     migrations(options: MigrationOptions): asyncMigrationsBuilder<D1Result>;
@@ -344,23 +475,13 @@ declare class D1QB extends QueryBuilder<D1Result> {
     batchExecute(queryArray: Query[]): Promise<any>;
 }
 
-declare class PGQB extends QueryBuilder<PGResult> {
-    db: any;
-    _migrationsBuilder: typeof asyncMigrationsBuilder;
-    constructor(db: any, options?: QueryBuilderOptions);
-    migrations(options: MigrationOptions): asyncMigrationsBuilder<PGResult>;
-    connect(): Promise<void>;
-    close(): Promise<void>;
-    execute(query: Query): Promise<any>;
-}
-
 interface SqlStorage {
     exec: any;
-    prepare: any;
+    get databaseSize(): number;
     Cursor: any;
     Statement: any;
 }
-declare class DOQB extends QueryBuilder<DOResult, false> {
+declare class DOQB<Schema extends TableSchema = {}> extends QueryBuilder<Schema, DOResult, false> {
     db: SqlStorage;
     loggerWrapper: typeof syncLoggerWrapper;
     constructor(db: SqlStorage, options?: QueryBuilderOptions<false>);
@@ -369,4 +490,14 @@ declare class DOQB extends QueryBuilder<DOResult, false> {
     lazyExecute(query: Query<any, false>): Iterable<any>;
 }
 
-export { type ArrayResult, type AsyncType, ConflictTypes, type ConflictUpsert, type CountResult, type D1Meta, D1QB, type D1Result, DOQB, type DOResult, type DefaultObject, type DefaultReturnObject, type Delete, type DeleteReturning, type DeleteWithoutReturning, FetchTypes, type FullArrayResult, type Insert, type InsertMultiple, type InsertOne, type InsertWithoutReturning, type IterableResult, type Join, JoinTypes, type MaybeAsync, type Migration, type MigrationEntry, type MigrationOptions, 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 SyncType, type Update, type UpdateReturning, type UpdateWithoutReturning, type Where, asyncLoggerWrapper, asyncMigrationsBuilder, defaultLogger, syncLoggerWrapper, syncMigrationsBuilder, type test, trimQuery };
+declare class PGQB<Schema extends TableSchema = {}> extends QueryBuilder<Schema, PGResult, true> {
+    db: any;
+    _migrationsBuilder: typeof asyncMigrationsBuilder;
+    constructor(db: any, options?: QueryBuilderOptions);
+    migrations(options: MigrationOptions): asyncMigrationsBuilder<PGResult>;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    execute(query: Query): Promise<any>;
+}
+
+export { type ArrayResult, type AsyncType, type ColumnName, ConflictTypes, type ConflictUpsert, type CountResult, type D1Meta, D1QB, type D1Result, DOQB, type DOResult, type DefaultObject, type DefaultReturnObject, type Delete, type DeleteReturning, type DeleteWithoutReturning, FetchTypes, type FullArrayResult, type InferResult, type Insert, type InsertData, type InsertMultiple, type InsertOne, type InsertWithoutReturning, type IsEmptySchema, type IterableResult, type Join, JoinTypes, type MaybeAsync, type Migration, type MigrationEntry, type MigrationOptions, 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 SchemaAware, type SelectAll, type SelectColumns, type SelectOne, type SyncType, type TableName, type TableSchema, type TypedDelete, type TypedInsert, type TypedSelectAll, type TypedSelectOne, type TypedUpdate, type Update, type UpdateData, type UpdateReturning, type UpdateWithoutReturning, type Where, asyncLoggerWrapper, asyncMigrationsBuilder, defaultLogger, syncLoggerWrapper, syncMigrationsBuilder, trimQuery };

package/dist/index.js

@@ -461,6 +461,8 @@ var QueryBuilder = class {
       }
     );
   }
+  // Implementation signature - uses any for compatibility with both overloads
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   fetchOne(params) {
     const queryArgs = [];
     const countQueryArgs = [];
@@ -487,6 +489,7 @@ var QueryBuilder = class {
       "ONE" /* ONE */
     );
   }
+  // Implementation signature - accepts any object with tableName
   fetchAll(params) {
     const queryArgs = [];
     const countQueryArgs = [];
@@ -525,6 +528,8 @@ var QueryBuilder = class {
       params.fetchType
     );
   }
+  // Implementation signature - accepts any object with tableName
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   insert(params) {
     let args = [];
     if (typeof params.onConflict === "object") {
@@ -552,6 +557,8 @@ var QueryBuilder = class {
       fetchType
     );
   }
+  // Implementation signature - accepts any object with tableName
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   update(params) {
     let args = this._parse_arguments(params.data);
     if (typeof params.where === "object" && !Array.isArray(params.where) && params.where?.params) {
@@ -570,6 +577,8 @@ var QueryBuilder = class {
       "ALL" /* ALL */
     );
   }
+  // Implementation signature - accepts any object with tableName
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   delete(params) {
     return new Query(
       (q) => {
@@ -615,7 +624,8 @@ var QueryBuilder = class {
     }
     const columns = Object.keys(data[0]).join(", ");
     let index = 1;
-    let orConflict = "", onConflict = "";
+    let orConflict = "";
+    let onConflict = "";
     if (params.onConflict && typeof params.onConflict === "object") {
       onConflict = this._onConflict(params.onConflict);
       if (typeof params.onConflict?.where === "object" && !Array.isArray(params.onConflict?.where) && params.onConflict?.where?.params) {
@@ -670,11 +680,12 @@ var QueryBuilder = class {
             FROM ${params.tableName}` + this._where(params.where) + this._returning(params.returning) + this._orderBy(params.orderBy) + this._limit(params.limit) + this._offset(params.offset);
   }
   _select(params, queryArgs) {
+    let newQueryArgs = queryArgs;
     const isTopLevelCall = queryArgs === void 0;
     if (isTopLevelCall) {
-      queryArgs = [];
+      newQueryArgs = [];
     }
-    const currentQueryArgs = queryArgs;
+    const currentQueryArgs = newQueryArgs;
     const context = {
       subQueryPlaceholders: params.subQueryPlaceholders,
       queryArgs: currentQueryArgs,
@@ -706,8 +717,9 @@ var QueryBuilder = class {
     if (conditionStrings.length === 0) return "";
     let primitiveParamIndex = 0;
     const processedConditions = [];
+    const seenNumberedParams = {};
     for (const conditionStr of conditionStrings) {
-      const parts = conditionStr.split(/(__SUBQUERY_TOKEN_\d+__|\?)/g).filter(Boolean);
+      const parts = conditionStr.split(/(__SUBQUERY_TOKEN_\d+__|\?\d+|\?)/g).filter(Boolean);
       let builtCondition = "";
       for (const part of parts) {
         if (part === "?") {
@@ -718,6 +730,18 @@ var QueryBuilder = class {
           }
           currentContext.queryArgs.push(primitiveParams[primitiveParamIndex++]);
           builtCondition += "?";
+        } else if (/^\?\d+$/.test(part)) {
+          const paramNum = part.slice(1);
+          if (!seenNumberedParams[paramNum]) {
+            seenNumberedParams[paramNum] = true;
+            if (primitiveParamIndex >= primitiveParams.length) {
+              throw new Error(
+                "SQL generation error: Not enough primitive parameters for numbered placeholders in WHERE clause."
+              );
+            }
+            currentContext.queryArgs.push(primitiveParams[primitiveParamIndex++]);
+          }
+          builtCondition += part;
         } else if (part.startsWith("__SUBQUERY_TOKEN_") && part.endsWith("__")) {
           if (!currentContext.subQueryPlaceholders || !currentContext.toSQLCompiler) {
             throw new Error("SQL generation error: Subquery context not provided for token processing.");
@@ -791,8 +815,9 @@ var QueryBuilder = class {
     if (conditionStrings.length === 0) return "";
     let primitiveParamIndex = 0;
     const processedConditions = [];
+    const seenNumberedParams = {};
     for (const conditionStr of conditionStrings) {
-      const parts = conditionStr.split(/(__SUBQUERY_TOKEN_\d+__|\?)/g).filter(Boolean);
+      const parts = conditionStr.split(/(__SUBQUERY_TOKEN_\d+__|\?\d+|\?)/g).filter(Boolean);
       let builtCondition = "";
       for (const part of parts) {
         if (part === "?") {
@@ -803,6 +828,18 @@ var QueryBuilder = class {
           }
           currentContext.queryArgs.push(primitiveParams[primitiveParamIndex++]);
           builtCondition += "?";
+        } else if (/^\?\d+$/.test(part)) {
+          const paramNum = part.slice(1);
+          if (!seenNumberedParams[paramNum]) {
+            seenNumberedParams[paramNum] = true;
+            if (primitiveParamIndex >= primitiveParams.length) {
+              throw new Error(
+                "SQL generation error: Not enough primitive parameters for numbered placeholders in HAVING clause."
+              );
+            }
+            currentContext.queryArgs.push(primitiveParams[primitiveParamIndex++]);
+          }
+          builtCondition += part;
         } else if (part.startsWith("__SUBQUERY_TOKEN_") && part.endsWith("__")) {
           if (!currentContext.subQueryPlaceholders || !currentContext.toSQLCompiler) {
             throw new Error("SQL generation error: Subquery context not provided for token processing.");
@@ -848,9 +885,8 @@ var QueryBuilder = class {
           objs.push(`${key} ${item}`);
         });
         return objs.join(", ");
-      } else {
-        return obj;
       }
+      return obj;
     });
     return ` ORDER BY ${result.join(", ")}`;
   }
@@ -871,9 +907,11 @@ var QueryBuilder = class {
 
 // src/migrations.ts
 var syncMigrationsBuilder = class {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   _builder;
   _migrations;
   _tableName;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   constructor(options, builder) {
     this._tableName = options.tableName || "migrations";
     this._migrations = options.migrations;
@@ -924,9 +962,11 @@ var syncMigrationsBuilder = class {
   }
 };
 var asyncMigrationsBuilder = class {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   _builder;
   _migrations;
   _tableName;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   constructor(options, builder) {
     this._tableName = options.tableName || "migrations";
     this._migrations = options.migrations;
@@ -1035,72 +1075,23 @@ var D1QB = class extends QueryBuilder {
               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,
-              rowsRead: resp.meta?.rows_read,
-              rowsWritten: resp.meta?.rows_written,
-              meta: resp.meta,
-              success: resp.success
-            };
           }
+          return {
+            changes: resp.meta?.changes,
+            duration: resp.meta?.duration,
+            last_row_id: resp.meta?.last_row_id,
+            served_by: resp.meta?.served_by,
+            rowsRead: resp.meta?.rows_read,
+            rowsWritten: resp.meta?.rows_written,
+            meta: resp.meta,
+            success: resp.success
+          };
         }
       );
     });
   }
 };
 
-// src/databases/pg.ts
-var PGQB = class extends QueryBuilder {
-  db;
-  _migrationsBuilder = asyncMigrationsBuilder;
-  constructor(db, options) {
-    super(options);
-    this.db = db;
-  }
-  migrations(options) {
-    return new asyncMigrationsBuilder(options, this);
-  }
-  async connect() {
-    await this.db.connect();
-  }
-  async close() {
-    await this.db.end();
-  }
-  async execute(query) {
-    return await this.loggerWrapper(query, this.options.logger, 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
-      };
-    });
-  }
-};
-
 // src/databases/do.ts
 var DOQB = class extends QueryBuilder {
   db;
@@ -1149,6 +1140,54 @@ var DOQB = class extends QueryBuilder {
     });
   }
 };
+
+// src/databases/pg.ts
+var PGQB = class extends QueryBuilder {
+  db;
+  _migrationsBuilder = asyncMigrationsBuilder;
+  constructor(db, options) {
+    super(options);
+    this.db = db;
+  }
+  migrations(options) {
+    return new asyncMigrationsBuilder(options, this);
+  }
+  async connect() {
+    await this.db.connect();
+  }
+  async close() {
+    await this.db.end();
+  }
+  async execute(query) {
+    return await this.loggerWrapper(query, this.options.logger, 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
+      };
+    });
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ConflictTypes,