@warlock.js/cascade 4.0.135 → 4.0.137

package/cjs/drivers/postgres/postgres-query-builder.js

@@ -1,155 +1,193 @@
-'use strict';var dataSourceRegistry=require('../../data-source/data-source-registry.js'),registerModel=require('../../model/register-model.js'),postgresQueryParser=require('./postgres-query-parser.js');/**
+'use strict';var dataSourceRegistry=require('../../data-source/data-source-registry.js'),registerModel=require('../../model/register-model.js'),queryBuilder=require('../../query-builder/query-builder.js'),postgresQueryParser=require('./postgres-query-parser.js');/**
  * PostgreSQL Query Builder
  *
- * Implements the QueryBuilderContract for PostgreSQL databases.
- * Provides a fluent API for building SQL queries with proper
- * parameter handling and type safety.
+ * Extends the pure QueryBuilder base with PostgreSQL-specific execution,
+ * SQL generation, relation hydration, and scope management.
  *
  * @module cascade/drivers/postgres
  */
+// ============================================================================
+// HELPER
+// ============================================================================
+/**
+ * Cast an Op[] to PostgresParserOperation[] — the shapes are compatible since
+ * both have `type: string` and `data: Record<string, unknown>`.
+ */
+function toParserOps(ops) {
+    return ops;
+}
+// ============================================================================
+// POSTGRES QUERY BUILDER
+// ============================================================================
 /**
  * PostgreSQL Query Builder.
  *
- * Implements the Cascade QueryBuilderContract for PostgreSQL.
- * Collects query operations and delegates to PostgresQueryParser
- * for SQL generation.
+ * Collects query operations (via the base class) and delegates SQL generation
+ * to `PostgresQueryParser`. Owns execution, hydration, and relation loading.
  *
  * @example
  * ```typescript
- * const users = await queryBuilder('users')
- *   .select(['id', 'name', 'email'])
- *   .where('status', 'active')
- *   .where('age', '>', 18)
- *   .orderBy('createdAt', 'desc')
+ * const users = await User.query()
+ *   .select(["id", "name", "email"])
+ *   .where("status", "active")
+ *   .orderBy("createdAt", "desc")
  *   .limit(10)
  *   .get();
  * ```
  */
-class PostgresQueryBuilder {
+class PostgresQueryBuilder extends queryBuilder.QueryBuilder {
     table;
-    /**
-     * Collected operations to be parsed into SQL.
-     */
-    operations = [];
-    /**
-     * Data source instance.
-     */
+    // ──────────────────────────────────────────────────────────────
+    // POSTGRES-SPECIFIC STATE
+    // ──────────────────────────────────────────────────────────────
+    /** Data source backing this builder. */
     dataSource;
-    /**
-     * Hydrate callback for transforming results.
-     */
+    /** Hydration callback for transforming result rows into model instances. */
     hydrateCallback;
-    /**
-     * Callback invoked before query execution.
-     */
+    /** Invoked before query execution. */
     fetchingCallback;
-    /**
-     * Callback invoked after records fetched but before hydration.
-     */
+    /** Invoked after fetch but before hydration. */
     hydratingCallback;
-    /**
-     * Callback invoked after records fetched and hydrated.
-     */
+    /** Invoked after fetch and hydration. */
     fetchedCallback;
     /**
-     * Pending global scopes.
-     */
-    pendingGlobalScopes;
-    /**
-     * Available local scopes.
+     * Map of relations registered via `joinWith()`.
+     * Keyed by dot-notation path (e.g. "organizationAiModel.aiModel").
      */
-    availableLocalScopes;
-    /**
-     * Disabled global scope names.
-     */
-    disabledGlobalScopes = new Set();
-    /**
-     * Whether scopes have been applied.
-     */
-    scopesApplied = false;
+    joinRelations = new Map();
+    // ──────────────────────────────────────────────────────────────
+    // CONSTRUCTOR
+    // ──────────────────────────────────────────────────────────────
     /**
-     * Create a new query builder.
-     *
      * @param table - Target table name
-     * @param dataSource - Optional data source (uses default if not provided)
+     * @param dataSource - Optional (uses default data source from registry if omitted)
      */
     constructor(table, dataSource) {
+        super();
         this.table = table;
         this.dataSource = dataSource ?? dataSourceRegistry.dataSourceRegistry.get();
     }
-    /**
-     * Get the PostgreSQL driver instance.
-     */
+    // ──────────────────────────────────────────────────────────────
+    // DRIVER
+    // ──────────────────────────────────────────────────────────────
     get driver() {
         return this.dataSource.driver;
     }
-    /**
-     * Add an operation to the operations list.
-     *
-     * @param type - Operation type
-     * @param data - Operation data
-     */
-    addOperation(type, data) {
-        this.operations.push({ type, data });
-    }
-    /**
-     * Clone this query builder with all current operations.
-     *
-     * @returns New query builder instance
-     */
+    // ──────────────────────────────────────────────────────────────
+    // CLONE
+    // ──────────────────────────────────────────────────────────────
     clone() {
         const cloned = new PostgresQueryBuilder(this.table, this.dataSource);
+        // Copy base-class state
         cloned.operations = [...this.operations];
-        cloned.hydrateCallback = this.hydrateCallback;
         cloned.pendingGlobalScopes = this.pendingGlobalScopes;
         cloned.availableLocalScopes = this.availableLocalScopes;
         cloned.disabledGlobalScopes = new Set(this.disabledGlobalScopes);
         cloned.scopesApplied = this.scopesApplied;
+        cloned.eagerLoadRelations = new Map(this.eagerLoadRelations);
+        cloned.countRelations = [...this.countRelations];
+        cloned.relationDefinitions = this.relationDefinitions;
+        cloned.modelClass = this.modelClass;
+        // Copy PG-specific state
+        cloned.hydrateCallback = this.hydrateCallback;
+        cloned.joinRelations = new Map(this.joinRelations);
         return cloned;
     }
     // ============================================================================
-    // HYDRATION
+    // PG-SPECIFIC FLUENT METHODS
     // ============================================================================
     /**
-     * Set a hydration callback to transform each result row.
+     * Native-query escape hatch. Passes `operations[]` to the callback for
+     * direct manipulation. Use sparingly — only when fluent API is insufficient.
      *
-     * @param callback - Transform function
-     * @returns This builder for chaining
+     * @example
+     * q.raw(ops => ops.push({ type: "whereRaw", data: { expression: "1=1" } }))
      */
-    hydrate(callback) {
-        this.hydrateCallback = callback;
+    raw(callback) {
+        callback(this.operations);
         return this;
     }
     /**
-     * Register callback invoked before query execution.
+     * Record a DISTINCT flag AND auto-select the field(s).
+     * In PostgreSQL, DISTINCT ON (col) requires the col to appear in SELECT.
      *
-     * @param callback - Callback function
-     * @returns Unsubscribe function
+     * @example
+     * q.distinctValues("category")               // SELECT category … DISTINCT ON (category)
+     * q.distinctValues(["category", "status"])   // both fields in DISTINCT ON and SELECT
      */
+    distinctValues(fields) {
+        // Record the base DISTINCT flag op
+        super.distinctValues(fields);
+        // Also add a select for the field(s) so they appear in the SELECT clause
+        if (fields) {
+            const fieldArr = Array.isArray(fields) ? fields : [fields];
+            this.addOperation("select", { fields: fieldArr });
+        }
+        return this;
+    }
+    /**
+     * Nearest-neighbour vector similarity search via pgvector cosine distance.
+     *
+     * Adds two operations atomically:
+     * 1. `selectRaw` → `1 - (column <=> $n::vector) AS <alias>`
+     *    Makes the similarity score available on every returned row.
+     * 2. `orderByRaw` → `column <=> $n::vector`
+     *    Tells the PostgreSQL query planner to use the IVFFlat/HNSW vector index.
+     *    Using the alias in ORDER BY would bypass the index — the raw expression is required.
+     *
+     * @example
+     * ```typescript
+     * const results = await Vector.query()
+     *   .where({ organization_id: "org-123", content_type: "summary" })
+     *   .nearestTo("embedding", queryEmbedding)
+     *   .limit(5)
+     *   .get<VectorRow & { score: number }>();
+     * ```
+     */
+    nearestTo(column, embedding, alias = "score") {
+        // pgvector expects the literal format: [n,n,n,...]
+        const literal = `[${embedding.join(",")}]`;
+        const quotedCol = this.driver.dialect.quoteIdentifier(column);
+        const quotedTable = this.driver.dialect.quoteIdentifier(this.table);
+        // 0 — Preserve all table columns.
+        //     Adding a selectRaw suppresses the parser's "SELECT *" fallback,
+        //     so we must explicitly include table.* before the score expression.
+        this.addOperation("selectRaw", {
+            expression: `${quotedTable}.*`,
+            bindings: [],
+        });
+        // 1 — Add similarity score to SELECT
+        this.addOperation("selectRaw", {
+            expression: `1 - (${quotedCol} <=> ?::vector) AS ${alias}`,
+            bindings: [literal],
+        });
+        // 2 — ORDER BY the raw expression so the vector index is used
+        this.addOperation("orderByRaw", {
+            expression: `${quotedCol} <=> ?::vector`,
+            bindings: [literal],
+        });
+        return this;
+    }
+    /** Set a hydration callback that transforms each result row. */
+    hydrate(callback) {
+        this.hydrateCallback = callback;
+        return this;
+    }
+    /** Register a callback invoked before query execution. */
     onFetching(callback) {
         this.fetchingCallback = callback;
         return () => {
             this.fetchingCallback = undefined;
         };
     }
-    /**
-     * Register callback invoked after fetch but before hydration.
-     *
-     * @param callback - Callback function
-     * @returns Unsubscribe function
-     */
+    /** Register a callback invoked after fetch but before hydration. */
     onHydrating(callback) {
         this.hydratingCallback = callback;
         return () => {
             this.hydratingCallback = undefined;
         };
     }
-    /**
-     * Register callback invoked after fetch and hydration.
-     *
-     * @param callback - Callback function
-     * @returns Unsubscribe function
-     */
+    /** Register a callback invoked after fetch and hydration. */
     onFetched(callback) {
         this.fetchedCallback = callback;
         return () => {
@@ -159,1300 +197,407 @@ class PostgresQueryBuilder {
     // ============================================================================
     // SCOPES
     // ============================================================================
-    /**
-     * Disable one or more global scopes for this query.
-     *
-     * @param scopeNames - Scope names to disable
-     * @returns This builder for chaining
-     */
-    withoutGlobalScope(...scopeNames) {
-        scopeNames.forEach((name) => this.disabledGlobalScopes.add(name));
-        return this;
-    }
-    /**
-     * Disable all global scopes for this query.
-     *
-     * @returns This builder for chaining
-     */
-    withoutGlobalScopes() {
-        if (this.pendingGlobalScopes) {
-            this.pendingGlobalScopes.forEach((_, name) => {
-                this.disabledGlobalScopes.add(name);
-            });
-        }
-        return this;
-    }
-    /**
-     * Apply a local scope to this query.
-     *
-     * @param scopeName - Name of the local scope
-     * @returns This builder for chaining
-     */
-    scope(scopeName) {
-        if (!this.availableLocalScopes) {
-            throw new Error("No local scopes available");
-        }
-        const scopeCallback = this.availableLocalScopes.get(scopeName);
-        if (!scopeCallback) {
-            throw new Error(`Local scope "${scopeName}" not found`);
-        }
-        scopeCallback(this);
-        return this;
-    }
-    /**
-     * Apply pending global scopes before query execution.
-     */
+    /** Apply pending global scopes to the operations list. */
     applyPendingScopes() {
-        if (!this.pendingGlobalScopes || this.scopesApplied) {
+        if (!this.pendingGlobalScopes || this.scopesApplied)
             return;
-        }
         const beforeOps = [];
         const afterOps = [];
         for (const [name, { callback, timing }] of this.pendingGlobalScopes) {
-            if (this.disabledGlobalScopes.has(name)) {
+            if (this.disabledGlobalScopes.has(name))
                 continue;
-            }
-            const tempBuilder = new PostgresQueryBuilder(this.table, this.dataSource);
-            callback(tempBuilder);
+            const temp = new PostgresQueryBuilder(this.table, this.dataSource);
+            callback(temp);
             if (timing === "before") {
-                beforeOps.push(...tempBuilder.operations);
+                beforeOps.push(...temp.operations);
             }
             else {
-                afterOps.push(...tempBuilder.operations);
+                afterOps.push(...temp.operations);
             }
         }
         this.operations = [...beforeOps, ...this.operations, ...afterOps];
         this.scopesApplied = true;
     }
-    where(...args) {
-        if (args.length === 1) {
-            if (typeof args[0] === "function") {
-                // Callback for nested conditions
-                const tempBuilder = new PostgresQueryBuilder(this.table, this.dataSource);
-                args[0](tempBuilder);
-                // Wrap nested operations
-                this.addOperation("where", { nested: tempBuilder.operations });
-            }
-            else if (typeof args[0] === "object") {
-                // Object conditions
-                for (const [key, value] of Object.entries(args[0])) {
-                    this.addOperation("where", { field: key, operator: "=", value });
-                }
-            }
-        }
-        else if (args.length === 2) {
-            this.addOperation("where", { field: args[0], operator: "=", value: args[1] });
+    // ============================================================================
+    // WHERE — POSTGRES-SPECIFIC (driver.dialect required)
+    // ============================================================================
+    /** Array field contains a value (or object with key). */
+    whereArrayContains(field, value, key) {
+        const quotedField = this.driver.dialect.quoteIdentifier(field);
+        if (key) {
+            this.addOperation("whereRaw", {
+                expression: `${quotedField} @> ?::jsonb`,
+                bindings: [JSON.stringify([{ [key]: value }])],
+            });
         }
-        else if (args.length === 3) {
-            this.addOperation("where", { field: args[0], operator: args[1], value: args[2] });
+        else {
+            this.addOperation("whereRaw", {
+                expression: `? = ANY(${quotedField})`,
+                bindings: [value],
+            });
         }
         return this;
     }
-    orWhere(...args) {
-        if (args.length === 2) {
-            this.addOperation("orWhere", { field: args[0], operator: "=", value: args[1] });
+    /** Array field does NOT contain a value (or object with key). */
+    whereArrayNotContains(field, value, key) {
+        const quotedField = this.driver.dialect.quoteIdentifier(field);
+        if (key) {
+            this.addOperation("whereRaw", {
+                expression: `NOT (${quotedField} @> ?::jsonb)`,
+                bindings: [JSON.stringify([{ [key]: value }])],
+            });
         }
-        else if (args.length === 3) {
-            this.addOperation("orWhere", { field: args[0], operator: args[1], value: args[2] });
+        else {
+            this.addOperation("whereRaw", {
+                expression: `NOT (? = ANY(${quotedField}))`,
+                bindings: [value],
+            });
         }
         return this;
     }
-    /**
-     * Add a raw WHERE clause.
-     */
-    whereRaw(expression, bindings) {
-        this.addOperation("whereRaw", { expression, bindings });
-        return this;
-    }
-    /**
-     * Add a raw OR WHERE clause.
-     */
-    orWhereRaw(expression, bindings) {
-        this.addOperation("orWhereRaw", { expression, bindings });
-        return this;
-    }
-    // ============================================================================
-    // WHERE CLAUSES - COLUMN COMPARISONS
-    // ============================================================================
-    /**
-     * Compare two columns.
-     */
-    whereColumn(first, operator, second) {
-        this.addOperation("whereColumn", { first, operator, second });
-        return this;
-    }
-    /**
-     * Compare two columns with OR.
-     */
-    orWhereColumn(first, operator, second) {
-        this.addOperation("orWhereColumn", { first, operator, second });
-        return this;
-    }
-    /**
-     * Compare multiple column pairs.
-     */
-    whereColumns(comparisons) {
-        for (const [left, operator, right] of comparisons) {
-            this.whereColumn(left, operator, right);
+    /** Array field contains value OR is empty. */
+    whereArrayHasOrEmpty(field, value, key) {
+        const quotedField = this.driver.dialect.quoteIdentifier(field);
+        if (key) {
+            this.addOperation("whereRaw", {
+                expression: `(${quotedField} @> ?::jsonb OR ${quotedField} = '[]'::jsonb OR ${quotedField} IS NULL)`,
+                bindings: [JSON.stringify([{ [key]: value }])],
+            });
+        }
+        else {
+            this.addOperation("whereRaw", {
+                expression: `(? = ANY(${quotedField}) OR array_length(${quotedField}, 1) IS NULL)`,
+                bindings: [value],
+            });
         }
         return this;
     }
-    /**
-     * Check if field is between two columns.
-     */
-    whereBetweenColumns(field, lowerColumn, upperColumn) {
-        this.addOperation("whereBetween", { field, lowerColumn, upperColumn, useColumns: true });
-        return this;
-    }
-    // ============================================================================
-    // WHERE CLAUSES - DATE OPERATIONS
-    // ============================================================================
-    /**
-     * Filter by date (ignoring time).
-     */
-    whereDate(field, value) {
-        this.addOperation("whereDate", { field, value });
-        return this;
-    }
-    /**
-     * Alias for whereDate.
-     */
-    whereDateEquals(field, value) {
-        return this.whereDate(field, value);
-    }
-    /**
-     * Filter for dates before a value.
-     */
-    whereDateBefore(field, value) {
-        this.addOperation("whereDateBefore", { field, value });
-        return this;
-    }
-    /**
-     * Filter for dates after a value.
-     */
-    whereDateAfter(field, value) {
-        this.addOperation("whereDateAfter", { field, value });
-        return this;
-    }
-    /**
-     * Filter by time.
-     */
-    whereTime(field, value) {
-        this.addOperation("where", { field, operator: "=", value, timeOnly: true });
-        return this;
-    }
-    /**
-     * Filter by day of month.
-     */
-    whereDay(field, value) {
-        this.addOperation("whereRaw", {
-            expression: `EXTRACT(DAY FROM ${field}) = ?`,
-            bindings: [value],
-        });
-        return this;
-    }
-    /**
-     * Filter by month.
-     */
-    whereMonth(field, value) {
-        this.addOperation("whereRaw", {
-            expression: `EXTRACT(MONTH FROM ${field}) = ?`,
-            bindings: [value],
-        });
-        return this;
-    }
-    /**
-     * Filter by year.
-     */
-    whereYear(field, value) {
-        this.addOperation("whereRaw", {
-            expression: `EXTRACT(YEAR FROM ${field}) = ?`,
-            bindings: [value],
-        });
-        return this;
-    }
-    // ============================================================================
-    // WHERE CLAUSES - JSON OPERATIONS
-    // ============================================================================
-    /**
-     * Check if JSON contains value.
-     */
-    whereJsonContains(path, value) {
-        this.addOperation("whereJsonContains", { path, value });
-        return this;
-    }
-    /**
-     * Check if JSON doesn't contain value.
-     */
-    whereJsonDoesntContain(path, value) {
-        this.addOperation("whereJsonDoesntContain", { path, value });
-        return this;
-    }
-    /**
-     * Check if JSON contains key.
-     */
-    whereJsonContainsKey(path) {
-        this.addOperation("whereRaw", {
-            expression: `${path} IS NOT NULL`,
-            bindings: [],
-        });
-        return this;
-    }
-    /**
-     * Check JSON array/string length.
-     */
-    whereJsonLength(path, operator, value) {
-        this.addOperation("whereRaw", {
-            expression: `jsonb_array_length(${path}) ${operator} ?`,
-            bindings: [value],
-        });
-        return this;
-    }
-    /**
-     * Check if JSON is array.
-     */
-    whereJsonIsArray(path) {
-        this.addOperation("whereRaw", {
-            expression: `jsonb_typeof(${path}) = 'array'`,
-            bindings: [],
-        });
-        return this;
-    }
-    /**
-     * Check if JSON is object.
-     */
-    whereJsonIsObject(path) {
-        this.addOperation("whereRaw", {
-            expression: `jsonb_typeof(${path}) = 'object'`,
-            bindings: [],
-        });
-        return this;
-    }
-    /**
-     * Check array length.
-     */
-    whereArrayLength(field, operator, value) {
-        this.addOperation("whereRaw", {
-            expression: `array_length(${field}, 1) ${operator} ?`,
-            bindings: [value],
-        });
+    /** Array field does NOT contain value OR is empty. */
+    whereArrayNotHaveOrEmpty(field, value, key) {
+        const quotedField = this.driver.dialect.quoteIdentifier(field);
+        if (key) {
+            this.addOperation("whereRaw", {
+                expression: `(NOT (${quotedField} @> ?::jsonb) OR ${quotedField} = '[]'::jsonb OR ${quotedField} IS NULL)`,
+                bindings: [JSON.stringify([{ [key]: value }])],
+            });
+        }
+        else {
+            this.addOperation("whereRaw", {
+                expression: `(NOT (? = ANY(${quotedField})) OR array_length(${quotedField}, 1) IS NULL)`,
+                bindings: [value],
+            });
+        }
         return this;
     }
     // ============================================================================
-    // WHERE CLAUSES - CONVENIENCE METHODS
+    // joinWith — RESOLVE RELATION DEFINITIONS
     // ============================================================================
     /**
-     * Filter by ID.
-     */
-    whereId(value) {
-        return this.where("id", value);
-    }
-    /**
-     * Filter by multiple IDs.
-     */
-    whereIds(values) {
-        return this.whereIn("id", values);
-    }
-    /**
-     * Filter by UUID.
-     */
-    whereUuid(value) {
-        return this.where("uuid", value);
-    }
-    /**
-     * Filter by ULID.
-     */
-    whereUlid(value) {
-        return this.where("ulid", value);
-    }
-    /**
-     * Full-text search.
-     */
-    whereFullText(fields, query) {
-        const fieldList = Array.isArray(fields) ? fields : [fields];
-        this.addOperation("whereFullText", { fields: fieldList, query });
-        return this;
-    }
-    /**
-     * Full-text search with OR.
-     */
-    orWhereFullText(fields, query) {
-        // TODO: Handle OR full-text
-        return this.whereFullText(fields, query);
-    }
-    /**
-     * Alias for whereFullText.
-     */
-    whereSearch(field, query) {
-        return this.whereFullText(field, query);
-    }
-    /**
-     * Negate conditions.
-     */
-    whereNot(callback) {
-        // TODO: Implement NOT wrapper
-        return this;
-    }
-    /**
-     * Negate conditions with OR.
-     */
-    orWhereNot(callback) {
-        // TODO: Implement OR NOT wrapper
-        return this;
-    }
-    // ============================================================================
-    // WHERE CLAUSES - COMPARISON OPERATORS
-    // ============================================================================
-    /**
-     * Filter by value in array.
-     */
-    whereIn(field, values) {
-        this.addOperation("whereIn", { field, values });
-        return this;
-    }
-    /**
-     * Filter by value not in array.
-     */
-    whereNotIn(field, values) {
-        this.addOperation("whereNotIn", { field, values });
-        return this;
-    }
-    /**
-     * Filter by NULL value.
-     */
-    whereNull(field) {
-        this.addOperation("whereNull", { field });
-        return this;
-    }
-    /**
-     * Filter by NOT NULL value.
-     */
-    whereNotNull(field) {
-        this.addOperation("whereNotNull", { field });
-        return this;
-    }
-    /**
-     * Filter by range (inclusive).
-     */
-    whereBetween(field, range) {
-        this.addOperation("whereBetween", { field, range });
-        return this;
-    }
-    /**
-     * Filter by not in range.
-     */
-    whereNotBetween(field, range) {
-        this.addOperation("whereNotBetween", { field, range });
-        return this;
-    }
-    // ============================================================================
-    // WHERE CLAUSES - PATTERN MATCHING
-    // ============================================================================
-    /**
-     * Filter by LIKE pattern (case-insensitive).
-     */
-    whereLike(field, pattern) {
-        const patternStr = pattern instanceof RegExp ? pattern.source : pattern;
-        this.addOperation("whereLike", { field, pattern: patternStr });
-        return this;
-    }
-    /**
-     * Filter by NOT LIKE pattern.
-     */
-    whereNotLike(field, pattern) {
-        const patternStr = pattern instanceof RegExp ? pattern.source : pattern;
-        this.addOperation("whereNotLike", { field, pattern: patternStr });
-        return this;
-    }
-    /**
-     * Filter by prefix.
-     */
-    whereStartsWith(field, value) {
-        return this.whereLike(field, `${value}%`);
-    }
-    /**
-     * Filter by not starting with prefix.
-     */
-    whereNotStartsWith(field, value) {
-        return this.whereNotLike(field, `${value}%`);
-    }
-    /**
-     * Filter by suffix.
-     */
-    whereEndsWith(field, value) {
-        return this.whereLike(field, `%${value}`);
-    }
-    /**
-     * Filter by not ending with suffix.
-     */
-    whereNotEndsWith(field, value) {
-        return this.whereNotLike(field, `%${value}`);
-    }
-    /**
-     * Filter by date range.
-     */
-    whereDateBetween(field, range) {
-        this.addOperation("whereDateBetween", { field, range });
-        return this;
-    }
-    /**
-     * Filter by not in date range.
-     */
-    whereDateNotBetween(field, range) {
-        // Use NOT BETWEEN
-        this.addOperation("whereNotBetween", { field, range });
-        return this;
-    }
-    whereExists(param) {
-        if (typeof param === "function") {
-            // Subquery exists
-            const tempBuilder = new PostgresQueryBuilder(this.table, this.dataSource);
-            param(tempBuilder);
-            this.addOperation("whereExists", { subquery: tempBuilder.operations });
-        }
-        else {
-            this.addOperation("whereNotNull", { field: param });
-        }
-        return this;
-    }
-    whereNotExists(param) {
-        if (typeof param === "function") {
-            const tempBuilder = new PostgresQueryBuilder(this.table, this.dataSource);
-            param(tempBuilder);
-            this.addOperation("whereNotExists", { subquery: tempBuilder.operations });
-        }
-        else {
-            this.addOperation("whereNull", { field: param });
-        }
-        return this;
-    }
-    whereSize(field, ...args) {
-        const operator = args.length === 2 ? args[0] : "=";
-        const size = args.length === 2 ? args[1] : args[0];
-        return this.whereArrayLength(field, operator, size);
-    }
-    /**
-     * Perform a full-text search.
-     */
-    textSearch(query, filters) {
-        // Apply filters if provided
-        if (filters) {
-            for (const [key, value] of Object.entries(filters)) {
-                this.where(key, value);
-            }
-        }
-        // Full-text search would need to know which columns to search
-        // For now, this is a placeholder - users should use whereFullText directly
-        return this;
-    }
-    /**
-     * Constrain an array field to contain the given value.
-     */
-    whereArrayContains(field, value, key) {
-        if (key) {
-            // Array of objects - use JSON containment check
-            this.addOperation("whereRaw", {
-                expression: `${this.driver.dialect.quoteIdentifier(field)} @> ?::jsonb`,
-                bindings: [JSON.stringify([{ [key]: value }])],
-            });
-        }
-        else {
-            // Simple array - check if value is in array
-            this.addOperation("whereRaw", {
-                expression: `? = ANY(${this.driver.dialect.quoteIdentifier(field)})`,
-                bindings: [value],
-            });
-        }
-        return this;
-    }
-    /**
-     * Constrain an array field to not contain the given value.
-     */
-    whereArrayNotContains(field, value, key) {
-        if (key) {
-            this.addOperation("whereRaw", {
-                expression: `NOT (${this.driver.dialect.quoteIdentifier(field)} @> ?::jsonb)`,
-                bindings: [JSON.stringify([{ [key]: value }])],
-            });
-        }
-        else {
-            this.addOperation("whereRaw", {
-                expression: `NOT (? = ANY(${this.driver.dialect.quoteIdentifier(field)}))`,
-                bindings: [value],
-            });
-        }
-        return this;
-    }
-    /**
-     * Constrain an array field to contain the value OR be empty.
-     */
-    whereArrayHasOrEmpty(field, value, key) {
-        const quotedField = this.driver.dialect.quoteIdentifier(field);
-        if (key) {
-            this.addOperation("whereRaw", {
-                expression: `(${quotedField} @> ?::jsonb OR ${quotedField} = '[]'::jsonb OR ${quotedField} IS NULL)`,
-                bindings: [JSON.stringify([{ [key]: value }])],
-            });
-        }
-        else {
-            this.addOperation("whereRaw", {
-                expression: `(? = ANY(${quotedField}) OR array_length(${quotedField}, 1) IS NULL)`,
-                bindings: [value],
-            });
-        }
-        return this;
-    }
-    /**
-     * Constrain an array field to not contain the value OR be empty.
-     */
-    whereArrayNotHaveOrEmpty(field, value, key) {
-        const quotedField = this.driver.dialect.quoteIdentifier(field);
-        if (key) {
-            this.addOperation("whereRaw", {
-                expression: `(NOT (${quotedField} @> ?::jsonb) OR ${quotedField} = '[]'::jsonb OR ${quotedField} IS NULL)`,
-                bindings: [JSON.stringify([{ [key]: value }])],
-            });
-        }
-        else {
-            this.addOperation("whereRaw", {
-                expression: `(NOT (? = ANY(${quotedField})) OR array_length(${quotedField}, 1) IS NULL)`,
-                bindings: [value],
-            });
-        }
-        return this;
-    }
-    join(...args) {
-        if (args.length === 3) {
-            this.addOperation("join", {
-                table: args[0],
-                localField: args[1],
-                foreignField: args[2],
-            });
-        }
-        else {
-            this.addOperation("join", args[0]);
-        }
-        return this;
-    }
-    leftJoin(...args) {
-        if (args.length === 3) {
-            this.addOperation("leftJoin", {
-                table: args[0],
-                localField: args[1],
-                foreignField: args[2],
-            });
-        }
-        else {
-            this.addOperation("leftJoin", args[0]);
-        }
-        return this;
-    }
-    rightJoin(...args) {
-        if (args.length === 3) {
-            this.addOperation("rightJoin", {
-                table: args[0],
-                localField: args[1],
-                foreignField: args[2],
-            });
-        }
-        else {
-            this.addOperation("rightJoin", args[0]);
-        }
-        return this;
-    }
-    innerJoin(...args) {
-        if (args.length === 3) {
-            this.addOperation("innerJoin", {
-                table: args[0],
-                localField: args[1],
-                foreignField: args[2],
-            });
-        }
-        else {
-            this.addOperation("innerJoin", args[0]);
-        }
-        return this;
-    }
-    fullJoin(...args) {
-        if (args.length === 3) {
-            this.addOperation("fullJoin", {
-                table: args[0],
-                localField: args[1],
-                foreignField: args[2],
-            });
-        }
-        else {
-            this.addOperation("fullJoin", args[0]);
-        }
-        return this;
-    }
-    /**
-     * Add a CROSS JOIN clause.
-     */
-    crossJoin(table) {
-        this.addOperation("crossJoin", { table });
-        return this;
-    }
-    /**
-     * Add a raw JOIN clause.
-     */
-    joinRaw(expression, bindings) {
-        this.addOperation("joinRaw", { expression, bindings });
-        return this;
-    }
-    select(...args) {
-        // Handle single array argument
-        if (args.length === 1 && Array.isArray(args[0])) {
-            this.addOperation("select", { fields: args[0] });
-        }
-        // Handle Record<string, 0 | 1 | boolean> (projection map)
-        else if (args.length === 1 && typeof args[0] === "object" && !Array.isArray(args[0])) {
-            this.addOperation("select", { fields: args[0] });
-        }
-        // Handle rest params (...fields)
-        else {
-            const flatFields = args.flat();
-            this.addOperation("select", { fields: flatFields });
-        }
-        return this;
-    }
-    /**
-     * Select a field with alias.
-     */
-    selectAs(field, alias) {
-        // Use select operation with alias format (Record<field, alias>)
-        this.addOperation("select", { fields: { [field]: alias } });
-        return this;
-    }
-    /**
-     * Select raw expression.
-     */
-    selectRaw(expression, bindings) {
-        this.addOperation("selectRaw", { expression, bindings });
-        return this;
-    }
-    /**
-     * Select multiple raw expressions.
-     */
-    selectRawMany(definitions) {
-        for (const def of definitions) {
-            this.selectRaw({ [def.alias]: def.expression }, def.bindings);
-        }
-        return this;
-    }
-    /**
-     * Select subquery.
-     */
-    selectSub(expression, alias) {
-        this.addOperation("selectRaw", { expression: { [alias]: expression } });
-        return this;
-    }
-    /**
-     * Add subquery to existing selection.
-     */
-    addSelectSub(expression, alias) {
-        return this.selectSub(expression, alias);
-    }
-    /**
-     * Select aggregate value.
-     */
-    selectAggregate(field, aggregate, alias) {
-        const expr = `${aggregate.toUpperCase()}(${field})`;
-        return this.selectRaw({ [alias]: expr });
-    }
-    /**
-     * Select existence check.
-     */
-    selectExists(field, alias) {
-        return this.selectRaw({ [alias]: `${field} IS NOT NULL` });
-    }
-    /**
-     * Select count.
-     */
-    selectCount(field, alias) {
-        return this.selectAggregate(field, "count", alias);
-    }
-    /**
-     * Select CASE expression.
-     */
-    selectCase(cases, otherwise, alias) {
-        const caseExpr = cases.map((c) => `WHEN ${c.when} THEN ${c.then}`).join(" ");
-        return this.selectRaw({ [alias]: `CASE ${caseExpr} ELSE ${otherwise} END` });
-    }
-    /**
-     * Select conditional (IF/ELSE).
-     */
-    selectWhen(condition, thenValue, elseValue, alias) {
-        return this.selectRaw({
-            [alias]: `CASE WHEN ${condition} THEN ${thenValue} ELSE ${elseValue} END`,
-        });
-    }
-    /**
-     * Direct projection manipulation.
-     */
-    selectDriverProjection(callback) {
-        // PostgreSQL doesn't have direct projection manipulation like MongoDB
-        return this;
-    }
-    /**
-     * Select JSON path.
-     */
-    selectJson(path, alias) {
-        const parts = path.split("->");
-        const column = parts[0];
-        const jsonPath = parts.slice(1).join("->");
-        const expr = jsonPath ? `${column}->>'${jsonPath}'` : column;
-        return alias ? this.selectAs(expr, alias) : this.selectRaw(expr);
-    }
-    /**
-     * Select JSON path with raw expression.
-     */
-    selectJsonRaw(path, expression, alias) {
-        return this.selectRaw({ [alias]: expression });
-    }
-    /**
-     * Exclude JSON path.
-     */
-    deselectJson(path) {
-        return this.deselect([path]);
-    }
-    /**
-     * Concatenate fields.
-     */
-    selectConcat(fields, alias) {
-        const expr = fields.join(" || ");
-        return this.selectRaw({ [alias]: expr });
-    }
-    /**
-     * Coalesce values.
-     */
-    selectCoalesce(fields, alias) {
-        const expr = `COALESCE(${fields.join(", ")})`;
-        return this.selectRaw({ [alias]: expr });
-    }
-    /**
-     * Window function.
-     */
-    selectWindow(spec) {
-        this.addOperation("selectRaw", { expression: spec });
-        return this;
-    }
-    /**
-     * Exclude columns from projection.
-     */
-    deselect(fields) {
-        this.addOperation("deselect", { fields });
-        return this;
-    }
-    /**
-     * Clear selection.
-     */
-    clearSelect() {
-        this.operations = this.operations.filter((op) => !op.type.startsWith("select") && op.type !== "deselect");
-        return this;
-    }
-    /**
-     * Select all columns.
-     */
-    selectAll() {
-        return this.clearSelect();
-    }
-    /**
-     * Restore default projection.
-     */
-    selectDefault() {
-        return this.clearSelect();
-    }
-    /**
-     * Select distinct values.
-     */
-    distinctValues(fields) {
-        this.addOperation("distinct", {});
-        if (fields) {
-            this.select(Array.isArray(fields) ? fields : [fields]);
-        }
-        return this;
-    }
-    /**
-     * Add additional select fields.
-     */
-    addSelect(fields) {
-        this.addOperation("select", { fields, add: true });
-        return this;
-    }
-    orderBy(...args) {
-        if (typeof args[0] === "string") {
-            this.addOperation("orderBy", { field: args[0], direction: args[1] ?? "asc" });
-        }
-        else {
-            for (const [field, direction] of Object.entries(args[0])) {
-                this.addOperation("orderBy", { field, direction });
+     * Load relations via SQL JOINs (single query) with optional per-relation constraints.
+     *
+     * Supports:
+     * - `joinWith("author")` / `joinWith(["author", "category"])`
+     * - `joinWith({ actions: q => q.where("status", "pending").limit(5) })`
+     * - `joinWith({ organizationAiModel: "id,name", actions: q => q.orderBy("sort_order") })`
+     *
+     * @example
+     * ChatMessage.joinWith({
+     *   actions: q => q.where("status", "pending").orderBy("sort_order", "asc").limit(5),
+     *   organizationAiModel: "id,createdAt",
+     * })
+     */
+    joinWith(...args) {
+        const entries = [];
+        for (const arg of args) {
+            if (typeof arg === "string") {
+                entries.push({ path: arg });
             }
-        }
-        return this;
-    }
-    /**
-     * Order descending.
-     */
-    orderByDesc(field) {
-        return this.orderBy(field, "desc");
-    }
-    /**
-     * Order with raw expression.
-     */
-    orderByRaw(expression, bindings) {
-        this.addOperation("orderByRaw", { expression, bindings });
-        return this;
-    }
-    /**
-     * Order randomly.
-     */
-    orderByRandom(limit) {
-        this.addOperation("orderByRaw", { expression: "RANDOM()" });
-        return this.limit(limit);
-    }
-    /**
-     * Get latest records.
-     */
-    async latest(column = "createdAt") {
-        return this.orderBy(column, "desc").get();
-    }
-    /**
-     * Get oldest records.
-     */
-    oldest(column = "createdAt") {
-        return this.orderBy(column, "asc");
-    }
-    // ============================================================================
-    // LIMITING / PAGINATION
-    // ============================================================================
-    /**
-     * Limit results.
-     */
-    limit(value) {
-        this.addOperation("limit", { value });
-        return this;
-    }
-    /**
-     * Skip results.
-     */
-    skip(value) {
-        this.addOperation("offset", { value });
-        return this;
-    }
-    /**
-     * Offset results.
-     */
-    offset(value) {
-        return this.skip(value);
-    }
-    /**
-     * Take first N results.
-     */
-    take(value) {
-        return this.limit(value);
-    }
-    /**
-     * Apply cursor pagination hints.
-     */
-    cursor(after, before) {
-        // Store cursor hints for cursorPaginate
-        return this;
-    }
-    // ============================================================================
-    // GROUPING / AGGREGATION
-    // ============================================================================
-    /**
-     * Group results.
-     */
-    groupBy(input) {
-        const fields = Array.isArray(input) ? input : [input];
-        this.addOperation("groupBy", { fields });
-        return this;
-    }
-    /**
-     * Raw GROUP BY.
-     */
-    groupByRaw(expression, bindings) {
-        this.addOperation("groupBy", { expression, bindings });
-        return this;
-    }
-    having(...args) {
-        if (args.length === 1) {
-            const input = args[0];
-            if (Array.isArray(input)) {
-                if (input.length === 2) {
-                    this.addOperation("having", { field: input[0], operator: "=", value: input[1] });
-                }
-                else {
-                    this.addOperation("having", { field: input[0], operator: input[1], value: input[2] });
+            else if (Array.isArray(arg)) {
+                for (const rel of arg) {
+                    entries.push({ path: rel });
                 }
             }
-            else {
-                for (const [key, value] of Object.entries(input)) {
-                    this.addOperation("having", { field: key, operator: "=", value });
+            else if (typeof arg === "object" && arg !== null) {
+                for (const [rel, val] of Object.entries(arg)) {
+                    entries.push({ path: rel, constraint: val });
                 }
             }
         }
-        else if (args.length === 2) {
-            this.addOperation("having", { field: args[0], operator: "=", value: args[1] });
-        }
-        else if (args.length === 3) {
-            this.addOperation("having", { field: args[0], operator: args[1], value: args[2] });
-        }
-        return this;
-    }
-    /**
-     * Raw HAVING clause.
-     */
-    havingRaw(expression, bindings) {
-        this.addOperation("havingRaw", { expression, bindings });
-        return this;
-    }
-    // ============================================================================
-    // EXECUTION METHODS
-    // ============================================================================
-    /**
-     * Execute query and get all results.
-     */
-    async get() {
-        this.applyPendingScopes();
-        // Apply JOIN operations for joinWith() relations
-        this.applyJoinRelations();
-        if (this.fetchingCallback) {
-            await this.fetchingCallback(this);
-        }
-        const parser = new postgresQueryParser.PostgresQueryParser({
-            table: this.table,
-            operations: this.operations,
-        });
-        const { sql, params } = parser.parse();
-        try {
-            const result = await this.driver.query(sql, params);
-            let records = result.rows;
-            // Extract joined relation data before hydration
-            const joinedData = this.extractJoinedRelationData(records);
-            if (this.hydratingCallback) {
-                await this.hydratingCallback(records, {});
-            }
-            if (this.hydrateCallback) {
-                records = records.map((row, index) => this.hydrateCallback(row, index));
-            }
-            // Attach joined relations to hydrated models
-            this.attachJoinedRelations(records, joinedData);
-            if (this.fetchedCallback) {
-                await this.fetchedCallback(records, {});
-            }
-            // Cleanup
-            this.operations = [];
-            return records;
-        }
-        catch (error) {
-            console.log("Error while executing:", sql, params);
-            console.log("Query Builder Error:", error);
-            throw error;
-        }
-    }
-    /**
-     * Apply JOIN operations for joinWith() relations.
-     */
-    applyJoinRelations() {
-        if (this.joinRelations.size === 0 || !this.relationDefinitions)
-            return;
-        for (const [relationName, config] of this.joinRelations) {
-            const relationDef = this.relationDefinitions[relationName];
-            if (!relationDef)
-                continue;
-            // Resolve the related model class
-            const RelatedModel = typeof relationDef.model === "string"
-                ? registerModel.getModelFromRegistry(relationDef.model)
-                : relationDef.model;
-            if (!RelatedModel)
-                continue;
-            const relatedTable = RelatedModel.table;
-            const alias = config.alias;
-            // Determine join keys based on relation type
-            let localField;
-            let foreignField;
-            if (relationDef.type === "belongsTo") {
-                localField = relationDef.foreignKey || `${relationName}Id`;
-                foreignField = relationDef.ownerKey || "id";
-            }
-            else {
-                // hasOne, hasMany
-                localField = relationDef.localKey || "id";
-                foreignField = relationDef.foreignKey || `${this.table.slice(0, -1)}Id`;
-            }
-            // Add LEFT JOIN operation
-            this.addOperation("leftJoin", {
-                table: relatedTable,
-                alias,
-                localField,
-                foreignField,
-            });
-            // Add SELECT for related columns with prefix
-            this.addOperation("selectRelatedColumns", {
-                alias,
-                relationName,
-                table: relatedTable,
-            });
-        }
-    }
-    /**
-     * Extract joined relation data from raw records.
-     * Returns a map of record index to relation data.
-     */
-    extractJoinedRelationData(records) {
-        const result = new Map();
-        if (this.joinRelations.size === 0)
-            return result;
-        records.forEach((record, index) => {
-            const relationData = {};
-            for (const [relationName, config] of this.joinRelations) {
-                const columnName = config.alias; // e.g., "_rel_author"
-                // Get the JSON object from the row_to_json column
-                const relatedData = record[columnName];
-                // Remove from main record so it doesn't appear in model.data
-                delete record[columnName];
-                // If null or all values are null, set to null
-                if (relatedData === null ||
-                    (typeof relatedData === "object" && Object.values(relatedData).every((v) => v === null))) {
-                    relationData[relationName] = null;
-                }
-                else {
-                    relationData[relationName] = relatedData;
-                }
-            }
-            result.set(index, relationData);
-        });
-        return result;
-    }
-    /**
-     * Attach joined relations to hydrated models.
-     */
-    attachJoinedRelations(records, joinedData) {
-        if (this.joinRelations.size === 0 || !this.relationDefinitions)
-            return;
-        records.forEach((model, index) => {
-            const relationData = joinedData.get(index);
-            if (!relationData)
-                return;
-            for (const [relationName, data] of Object.entries(relationData)) {
-                if (data === null) {
-                    // No related record
-                    model[relationName] = null;
-                    if (model.loadedRelations) {
-                        model.loadedRelations.set(relationName, null);
+        for (const { path, constraint } of entries) {
+            // Parse each dot-notation path segment (supports "rel1.rel2" nesting)
+            const segments = path.split(".");
+            let currentModel = this.modelClass;
+            let currentPath = "";
+            for (let i = 0; i < segments.length; i++) {
+                const rawSeg = segments[i];
+                // String shorthand: "relName:col1,col2"
+                const colonIdx = rawSeg.indexOf(":");
+                const segName = colonIdx === -1 ? rawSeg : rawSeg.slice(0, colonIdx);
+                const segColumns = colonIdx === -1
+                    ? undefined
+                    : rawSeg
+                        .slice(colonIdx + 1)
+                        .split(",")
+                        .filter(Boolean);
+                currentPath = currentPath ? `${currentPath}.${segName}` : segName;
+                // If already registered, update if new select columns given; advance model
+                if (this.joinRelations.has(currentPath)) {
+                    const existing = this.joinRelations.get(currentPath);
+                    if (segColumns)
+                        existing.select = segColumns;
+                    // Apply constraint only on the deepest segment
+                    if (i === segments.length - 1 && constraint !== undefined) {
+                        existing.constraintOps = this._resolveConstraintOps(constraint);
                     }
+                    currentModel =
+                        typeof existing.model === "string"
+                            ? registerModel.getModelFromRegistry(existing.model)
+                            : existing.model;
                     continue;
                 }
-                const relationDef = this.relationDefinitions[relationName];
-                if (!relationDef)
+                if (!this.relationDefinitions)
                     continue;
-                // Resolve and hydrate the related model
-                const RelatedModel = typeof relationDef.model === "string"
-                    ? registerModel.getModelFromRegistry(relationDef.model)
-                    : relationDef.model;
-                if (RelatedModel) {
-                    const relatedInstance = new RelatedModel(data);
-                    relatedInstance.isNew = false;
-                    model[relationName] = relatedInstance;
-                    if (model.loadedRelations) {
-                        model.loadedRelations.set(relationName, relatedInstance);
+                const def = (i === 0
+                    ? this.relationDefinitions
+                    : currentModel?.relations)?.[segName];
+                if (!def) {
+                    throw new Error(`Relation "${segName}" not found on model ${currentModel?.name ?? "unknown"}`);
+                }
+                // Resolve select columns: colon shorthand > constraint string > def.select
+                let selectColumns = segColumns ?? def.select;
+                let constraintOps;
+                if (i === segments.length - 1 && constraint !== undefined) {
+                    if (typeof constraint === "string") {
+                        selectColumns = constraint.split(",").filter(Boolean);
+                    }
+                    else {
+                        constraintOps = this._resolveConstraintOps(constraint);
                     }
                 }
+                const alias = currentPath.replace(/\./g, "_");
+                this.joinRelations.set(currentPath, {
+                    alias,
+                    type: def.type,
+                    model: def.model,
+                    localKey: def.localKey,
+                    foreignKey: def.foreignKey,
+                    ownerKey: def.ownerKey,
+                    parentPath: i > 0 ? currentPath.substring(0, currentPath.lastIndexOf(".")) : null,
+                    relationName: segName,
+                    parentModel: currentModel,
+                    select: selectColumns,
+                    constraintOps,
+                });
+                currentModel =
+                    typeof def.model === "string" ? registerModel.getModelFromRegistry(def.model) : def.model;
+                if (!currentModel) {
+                    throw new Error(`Relation model not found for "${segName}" in "${currentPath}"`);
+                }
             }
-        });
+        }
+        return this;
     }
+    /** Run a joinWith constraint callback against a sub-QB and capture its operations. */
+    _resolveConstraintOps(constraint) {
+        if (typeof constraint === "string")
+            return [];
+        const sub = new PostgresQueryBuilder("__sub__", this.dataSource);
+        constraint(sub);
+        return sub.operations;
+    }
+    // ============================================================================
+    // EXECUTION METHODS
+    // ============================================================================
     /**
-     * Get first result.
+     * Execute the query and return all matching rows.
      */
+    async get() {
+        this.applyPendingScopes();
+        this._processJoinWithOps();
+        this.applyJoinRelations();
+        if (this.fetchingCallback) {
+            await this.fetchingCallback(this);
+        }
+        const parser = new postgresQueryParser.PostgresQueryParser({
+            table: this.table,
+            operations: toParserOps(this.operations),
+        });
+        const { query = "", bindings = [] } = parser.parse();
+        try {
+            const result = await this.driver.query(query, bindings);
+            let records = result.rows;
+            const joinedData = this.extractJoinedRelationData(records);
+            if (this.hydratingCallback) {
+                await this.hydratingCallback(records, {});
+            }
+            if (this.hydrateCallback) {
+                records = records.map((row, index) => this.hydrateCallback(row, index));
+            }
+            this.attachJoinedRelations(records, joinedData);
+            if (this.fetchedCallback) {
+                await this.fetchedCallback(records, {});
+            }
+            this.operations = [];
+            return records;
+        }
+        catch (error) {
+            console.log("Error while executing:", query, bindings);
+            console.log("Query Builder Error:", error);
+            throw error;
+        }
+    }
+    /** Get first result. */
     async first() {
         const results = await this.limit(1).get();
         return results[0] ?? null;
     }
-    /**
-     * Get last result.
-     */
+    /** Get last result (by id desc). */
     async last() {
         const results = await this.orderByDesc("id").limit(1).get();
         return results[0] ?? null;
     }
-    /**
-     * Get random results.
-     */
+    /** Get random results. */
     async random(limit) {
         this.orderByRaw("RANDOM()");
-        if (limit) {
+        if (limit)
             this.limit(limit);
-        }
         return this.get();
     }
-    /**
-     * Get first or throw.
-     */
+    /** Get first or throw. */
     async firstOrFail() {
         const result = await this.first();
-        if (!result) {
+        if (!result)
             throw new Error("No records found");
-        }
         return result;
     }
-    /**
-     * Get first or call callback.
-     */
+    /** Get first or call callback. */
     async firstOr(callback) {
         const result = await this.first();
         return result ?? (await callback());
     }
-    /**
-     * Get first or return default.
-     */
+    /** Get first or return null. */
     async firstOrNull() {
         return this.first();
     }
-    /**
-     * Get first or create new.
-     */
+    /** Get first or return default. */
     async firstOrNew(defaults) {
         const result = await this.first();
         return result ?? defaults;
     }
-    /**
-     * Find by ID.
-     */
+    /** Find by primary key. */
     async find(id) {
         return this.where("id", id).first();
     }
-    /**
-     * Count results.
-     */
+    /** Count matching rows. */
     async count() {
         this.applyPendingScopes();
-        // Build count query using selectRaw to avoid quoting COUNT(*) as a column
-        const countOps = [
+        const countOps = toParserOps([
             ...this.operations.filter((op) => op.type.includes("where") || op.type.includes("join")),
             { type: "selectRaw", data: { expression: 'COUNT(*) AS "count"' } },
-        ];
-        const parser = new postgresQueryParser.PostgresQueryParser({
-            table: this.table,
-            operations: countOps,
-        });
-        const { sql, params } = parser.parse();
-        const result = await this.driver.query(sql, params);
+        ]);
+        const parser = new postgresQueryParser.PostgresQueryParser({ table: this.table, operations: countOps });
+        const { query = "", bindings = [] } = parser.parse();
+        const result = await this.driver.query(query, bindings);
         return parseInt(result.rows[0]?.count ?? "0", 10);
     }
-    /**
-     * Sum of field values.
-     */
+    /** SUM a numeric field. */
     async sum(field) {
         this.applyPendingScopes();
         const result = await this.selectRaw(`SUM(${field}) as sum`).first();
         return parseFloat(result?.sum ?? "0");
     }
-    /**
-     * Average of field values.
-     */
+    /** AVG of a numeric field. */
     async avg(field) {
         this.applyPendingScopes();
         const result = await this.selectRaw(`AVG(${field}) as avg`).first();
         return parseFloat(result?.avg ?? "0");
     }
-    /**
-     * Minimum field value.
-     */
+    /** MIN of a numeric field. */
     async min(field) {
         this.applyPendingScopes();
         const result = await this.selectRaw(`MIN(${field}) as min`).first();
         return parseFloat(result?.min ?? "0");
     }
-    /**
-     * Maximum field value.
-     */
+    /** MAX of a numeric field. */
     async max(field) {
         this.applyPendingScopes();
         const result = await this.selectRaw(`MAX(${field}) as max`).first();
         return parseFloat(result?.max ?? "0");
     }
-    /**
-     * Get distinct values.
-     */
+    /** Get distinct values for a field. */
     async distinct(field) {
         this.distinctValues(field);
         const results = await this.get();
         return results.map((row) => row[field]);
     }
-    /**
-     * Get array of values for field.
-     */
+    /** Get array of all values for a single field. */
     async pluck(field) {
         const results = await this.select([field]).get();
         return results.map((row) => row[field]);
     }
-    /**
-     * Get single scalar value.
-     */
+    /** Get a single scalar value. */
     async value(field) {
         const result = await this.select([field]).first();
         return result?.[field] ?? null;
     }
-    /**
-     * Check if records exist.
-     */
+    /** Check whether any matching rows exist. */
     async exists() {
         const count = await this.limit(1).count();
         return count > 0;
     }
-    /**
-     * Check if no records exist.
-     */
+    /** Check whether NO matching rows exist. */
     async notExists() {
         return !(await this.exists());
     }
-    /**
-     * Count distinct values.
-     */
+    /** COUNT DISTINCT a field. */
     async countDistinct(field) {
         const result = await this.selectRaw(`COUNT(DISTINCT ${field}) as count`).first();
         return parseInt(result?.count ?? "0", 10);
     }
-    /**
-     * Increment field value.
-     */
+    // ─── Aggregation shortcuts via latest/oldest ─────────────────
+    /** Get latest records ordered by a column. */
+    async latest(column = "createdAt") {
+        return this.orderBy(column, "desc").get();
+    }
+    // ─── Increment / Decrement ───────────────────────────────────
+    /** Increment a numeric field. Returns new value. */
     async increment(field, amount = 1) {
         this.applyPendingScopes();
-        const { sql, params } = this.buildFilter();
-        const updateSql = `UPDATE ${this.driver.dialect.quoteIdentifier(this.table)} SET ${this.driver.dialect.quoteIdentifier(field)} = COALESCE(${this.driver.dialect.quoteIdentifier(field)}, 0) + $1 WHERE ${sql.replace("WHERE ", "")} RETURNING ${this.driver.dialect.quoteIdentifier(field)}`;
-        const result = await this.driver.query(updateSql, [amount, ...params]);
+        const { sql: filterSql, params: filterParams } = this.buildFilter();
+        const updateSql = `UPDATE ${this.driver.dialect.quoteIdentifier(this.table)} ` +
+            `SET ${this.driver.dialect.quoteIdentifier(field)} = COALESCE(${this.driver.dialect.quoteIdentifier(field)}, 0) + $1 ` +
+            (filterSql ? `WHERE ${filterSql.replace("WHERE ", "")} ` : "") +
+            `RETURNING ${this.driver.dialect.quoteIdentifier(field)}`;
+        const result = await this.driver.query(updateSql, [
+            amount,
+            ...filterParams,
+        ]);
         return result.rows[0]?.[field] ?? 0;
     }
-    /**
-     * Decrement field value.
-     */
+    /** Decrement a numeric field. Returns new value. */
     async decrement(field, amount = 1) {
         return this.increment(field, -amount);
     }
-    /**
-     * Increment for all matching.
-     */
+    /** Increment a field for all matching rows. Returns affected row count. */
     async incrementMany(field, amount = 1) {
         this.applyPendingScopes();
-        const { sql, params } = this.buildFilter();
-        const updateSql = `UPDATE ${this.driver.dialect.quoteIdentifier(this.table)} SET ${this.driver.dialect.quoteIdentifier(field)} = COALESCE(${this.driver.dialect.quoteIdentifier(field)}, 0) + $1 WHERE ${sql.replace("WHERE ", "")}`;
-        const result = await this.driver.query(updateSql, [amount, ...params]);
+        const { sql: filterSql, params: filterParams } = this.buildFilter();
+        const updateSql = `UPDATE ${this.driver.dialect.quoteIdentifier(this.table)} ` +
+            `SET ${this.driver.dialect.quoteIdentifier(field)} = COALESCE(${this.driver.dialect.quoteIdentifier(field)}, 0) + $1` +
+            (filterSql ? ` WHERE ${filterSql.replace("WHERE ", "")}` : "");
+        const result = await this.driver.query(updateSql, [amount, ...filterParams]);
         return result.rowCount ?? 0;
     }
-    /**
-     * Decrement for all matching.
-     */
+    /** Decrement a field for all matching rows. Returns affected row count. */
     async decrementMany(field, amount = 1) {
         return this.incrementMany(field, -amount);
     }
-    // ============================================================================
-    // CHUNKING / PAGINATION
-    // ============================================================================
+    // ─── Chunking / Pagination ───────────────────────────────────
     /**
-     * Process results in chunks.
+     * Process results in memory-efficient chunks.
+     *
+     * @example
+     * await User.query().chunk(100, async (rows, idx) => { ... })
      */
     async chunk(size, callback) {
         let chunkIndex = 0;
@@ -1462,20 +607,16 @@ class PostgresQueryBuilder {
                 .skip(chunkIndex * size)
                 .limit(size)
                 .get();
-            if (chunk.length === 0) {
+            if (chunk.length === 0)
                 break;
-            }
             const shouldContinue = await callback(chunk, chunkIndex);
-            if (shouldContinue === false) {
+            if (shouldContinue === false)
                 break;
-            }
             hasMore = chunk.length === size;
             chunkIndex++;
         }
     }
-    /**
-     * Page-based pagination.
-     */
+    /** Page-based pagination. */
     async paginate(options) {
         const page = options?.page ?? 1;
         const limit = options?.limit ?? 10;
@@ -1495,22 +636,32 @@ class PostgresQueryBuilder {
         };
     }
     /**
-     * Cursor-based pagination.
+     * Set cursor pagination hints fluently.
+     * The recorded values are picked up by `cursorPaginate()` when no explicit
+     * options are passed.
+     *
+     * @example
+     * User.query().cursor(lastId).cursorPaginate({ limit: 20 })
      */
+    cursor(after, before) {
+        this.addOperation("cursor", { after, before });
+        return this;
+    }
+    /** Cursor-based pagination. */
     async cursorPaginate(options) {
-        const { limit = 10, cursor, column = "id", direction = "next" } = options ?? {};
+        // Fall back to fluently-recorded cursor op if options.cursor not provided
+        const cursorOp = this.getOps("cursor")[0];
+        const recordedCursor = cursorOp?.data.after;
+        const { limit = 10, cursor = recordedCursor, column = "id", direction = "next", } = options ?? {};
         if (cursor) {
-            const operator = direction === "next" ? ">" : "<";
-            this.where(column, operator, cursor);
+            this.where(column, direction === "next" ? ">" : "<", cursor);
         }
-        const sortOrder = direction === "next" ? "asc" : "desc";
-        this.orderBy(column, sortOrder);
+        this.orderBy(column, direction === "next" ? "asc" : "desc");
         const results = await this.limit(limit + 1).get();
         const hasMore = results.length > limit;
         let data = hasMore ? results.slice(0, limit) : results;
-        if (direction === "prev") {
+        if (direction === "prev")
             data = data.reverse();
-        }
         let nextCursor;
         let prevCursor;
         let hasPrev = false;
@@ -1527,27 +678,14 @@ class PostgresQueryBuilder {
             else {
                 prevCursor = hasMore ? firstItem : undefined;
                 hasPrev = hasMore;
-                if (cursor) {
+                if (cursor)
                     nextCursor = lastItem;
-                }
             }
         }
-        return {
-            data,
-            pagination: {
-                hasMore,
-                hasPrev,
-                nextCursor,
-                prevCursor,
-            },
-        };
+        return { data, pagination: { hasMore, hasPrev, nextCursor, prevCursor } };
     }
-    // ============================================================================
-    // MUTATION METHODS
-    // ============================================================================
-    /**
-     * Delete matching records.
-     */
+    // ─── Mutation methods ────────────────────────────────────────
+    /** Delete matching rows. Returns deleted count. */
     async delete() {
         this.applyPendingScopes();
         const { sql, params } = this.buildFilter();
@@ -1555,246 +693,241 @@ class PostgresQueryBuilder {
         const result = await this.driver.query(deleteSql, params);
         return result.rowCount ?? 0;
     }
-    /**
-     * Delete first matching record.
-     */
+    /** Delete the first matching row. */
     async deleteOne() {
         return this.limit(1).delete();
     }
-    /**
-     * Update matching records.
-     */
+    /** Update matching rows. */
     async update(fields) {
         this.applyPendingScopes();
         const result = await this.driver.updateMany(this.table, {}, { $set: fields });
         return result.modifiedCount;
     }
-    /**
-     * Unset fields from matching records.
-     */
+    /** Unset fields from matching rows. */
     async unset(...fields) {
         this.applyPendingScopes();
         const updateObj = {};
-        for (const field of fields) {
+        for (const field of fields)
             updateObj[field] = 1;
-        }
         const result = await this.driver.updateMany(this.table, {}, { $unset: updateObj });
         return result.modifiedCount;
     }
-    // ============================================================================
-    // INSPECTION / DEBUGGING
-    // ============================================================================
-    /**
-     * Get the raw SQL query.
-     */
+    // ─── Inspection / Debugging ───────────────────────────────────
+    /** Return the SQL + bindings without executing. */
     parse() {
         this.applyPendingScopes();
         const parser = new postgresQueryParser.PostgresQueryParser({
             table: this.table,
-            operations: this.operations,
+            operations: toParserOps(this.operations),
         });
         return parser.parse();
     }
-    /**
-     * Get formatted SQL string.
-     */
+    /** Formatted SQL string (for logging/debugging). */
     pretty() {
-        const { sql, params } = this.parse();
-        return `${sql}\n-- Parameters: ${JSON.stringify(params)}`;
+        const { query = "", bindings } = this.parse();
+        return `${query}\n-- Bindings: ${JSON.stringify(bindings ?? [])}`;
     }
-    /**
-     * Get query execution plan.
-     */
+    /** Run EXPLAIN ANALYZE on the query. */
     async explain() {
-        const { sql, params } = this.parse();
-        const explainSql = `EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) ${sql}`;
-        const result = await this.driver.query(explainSql, params);
+        const { query = "", bindings = [] } = this.parse();
+        const result = await this.driver.query(`EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) ${query}`, bindings);
         return result.rows;
     }
-    // ============================================================================
-    // UTILITY METHODS
-    // ============================================================================
-    /**
-     * Add driver-specific raw modifications to the query.
-     */
-    raw(builder) {
-        // For PostgreSQL, the native object would be the operations array
-        builder(this.operations);
-        return this;
-    }
-    /**
-     * Extend the query builder with driver-specific extensions.
-     */
+    // ─── Utility ──────────────────────────────────────────────────
+    /** Extend the builder with a driver-specific extension. */
     extend(extension, ..._args) {
-        // PostgreSQL doesn't have driver-specific extensions like MongoDB
-        // Return undefined as R for now - specific extensions can be added later
         throw new Error(`Extension "${extension}" is not supported by PostgresQueryBuilder`);
     }
-    /**
-     * Tap into the query builder for side-effects.
-     */
-    tap(callback) {
-        callback(this);
-        return this;
-    }
-    /**
-     * Conditionally apply query modifications.
-     */
-    when(condition, callback, otherwise) {
-        if (condition) {
-            callback(this, condition);
-        }
-        else if (otherwise) {
-            otherwise(this);
-        }
-        return this;
+    /** Pluck scalar values for a single field (alias for pluck). */
+    async pluckOne(field) {
+        const results = await this.select([field]).get();
+        return results.map((row) => row[field]);
     }
     // ============================================================================
-    // INTERNAL HELPERS
+    // JOIN RELATIONS — INTERNAL PIPELINE
     // ============================================================================
     /**
-     * Build WHERE clause from current operations.
+     * Before `get()` runs the parser, consume any joinWith ops recorded by the base
+     * class and expand them into the joinRelations Map.
      */
-    buildFilter() {
-        const whereOps = this.operations.filter((op) => op.type.includes("where") || op.type.includes("Where"));
-        if (whereOps.length === 0) {
-            return { sql: "", params: [] };
+    _processJoinWithOps() {
+        const joinWithOps = this.operations.filter((op) => op.type === "joinWith");
+        if (joinWithOps.length === 0)
+            return;
+        // Remove joinWith ops from main operations — they are consumed here
+        this.operations = this.operations.filter((op) => op.type !== "joinWith");
+        for (const op of joinWithOps) {
+            const constraints = op.data.constraints;
+            for (const [path, constraint] of Object.entries(constraints)) {
+                // Re-delegate to the extended joinWith implementation
+                if (!constraint || constraint === "") {
+                    this.joinWith(path);
+                }
+                else {
+                    this.joinWith({ [path]: constraint });
+                }
+            }
         }
-        const parser = new postgresQueryParser.PostgresQueryParser({
-            table: this.table,
-            operations: whereOps,
-        });
-        const { sql, params } = parser.parse();
-        const whereMatch = sql.match(/WHERE .+$/);
-        return {
-            sql: whereMatch ? whereMatch[0] : "",
-            params,
-        };
     }
-    // ============================================================================
-    // RELATIONS / EAGER LOADING (Stubs)
-    // ============================================================================
-    /**
-     * Relations to eagerly load.
-     */
-    eagerLoadRelations = new Map();
-    /**
-     * Relations to count.
-     */
-    countRelations = [];
-    /**
-     * Relations to load via JOIN (single query).
-     */
-    joinRelations = new Map();
-    /**
-     * Relation definitions from the model.
-     */
-    relationDefinitions;
-    /**
-     * Model class reference.
-     */
-    modelClass;
     /**
-     * Load relations using database JOINs in a single query.
-     *
-     * Unlike `with()` which uses separate queries, `joinWith()` uses
-     * LEFT JOIN to fetch related data in a single query.
-     *
-     * @param relations - Relation names to load via JOIN
-     * @returns This builder for chaining
+     * Translate each entry in `joinRelations` into actual JOIN + selectRelatedColumns operations.
      */
-    joinWith(...relations) {
-        for (const relation of relations) {
-            const def = this.relationDefinitions?.[relation];
-            if (def) {
-                this.joinRelations.set(relation, {
-                    alias: `_rel_${relation}`,
-                    type: def.type,
+    applyJoinRelations() {
+        if (this.joinRelations.size === 0)
+            return;
+        for (const [path, config] of this.joinRelations) {
+            const RelatedModel = typeof config.model === "string"
+                ? registerModel.getModelFromRegistry(config.model)
+                : config.model;
+            if (!RelatedModel) {
+                throw new Error(`Relation model not found for ${path}`);
+            }
+            const relatedTable = RelatedModel.table;
+            const alias = config.alias;
+            const parentTable = config.parentPath
+                ? this.joinRelations.get(config.parentPath).alias
+                : this.table;
+            const parentDefTable = config.parentModel?.table ?? this.table;
+            let localField;
+            let foreignField;
+            if (config.type === "belongsTo") {
+                localField = config.foreignKey ?? `${config.relationName}Id`;
+                foreignField = config.ownerKey ?? "id";
+            }
+            else {
+                localField = config.localKey ?? "id";
+                foreignField = config.foreignKey ?? `${parentDefTable.slice(0, -1)}Id`;
+            }
+            // hasMany uses a correlated subquery in SELECT (no JOIN) to avoid row explosion
+            if (config.type !== "hasMany") {
+                this.addOperation("leftJoin", {
+                    table: relatedTable,
+                    alias,
+                    localField: `${parentTable}.${localField}`,
+                    foreignField,
                 });
             }
+            this.addOperation("selectRelatedColumns", {
+                alias,
+                relationName: config.relationName,
+                path,
+                table: relatedTable,
+                select: config.select,
+                type: config.type,
+                foreignKey: foreignField,
+                localKey: localField,
+                parentTable,
+                constraintOps: config.constraintOps, // passed through to parser
+            });
         }
-        return this;
     }
     /**
-     * Eagerly load one or more relations.
-     *
-     * Supported patterns:
-     * - `with("posts")` - Load relation
-     * - `with("posts", "comments")` - Load multiple relations
-     * - `with("posts", callback)` - Load relation with constraint
-     * - `with({ posts: true, comments: callback })` - Object configuration
-     *
-     * @param args - Relation name(s), callbacks, or configuration object
+     * Extract per-relation data from raw DB rows (before hydration).
+     * Returns a Map of row index → nested relation data tree.
      */
-    with(...args) {
-        for (let i = 0; i < args.length; i++) {
-            const arg = args[i];
-            if (typeof arg === "string") {
-                // Check if next argument is a callback for this relation
-                const nextArg = args[i + 1];
-                if (typeof nextArg === "function") {
-                    this.eagerLoadRelations.set(arg, nextArg);
-                    i++; // Skip the callback in next iteration
-                }
-                else {
-                    this.eagerLoadRelations.set(arg, true);
-                }
-            }
-            else if (typeof arg === "object" && arg !== null) {
-                for (const [key, value] of Object.entries(arg)) {
-                    this.eagerLoadRelations.set(key, value);
+    extractJoinedRelationData(records) {
+        const result = new Map();
+        if (this.joinRelations.size === 0)
+            return result;
+        records.forEach((record, index) => {
+            const relationData = {};
+            // Process shallower paths first so parents exist before children
+            const sortedPaths = Array.from(this.joinRelations.keys()).sort((a, b) => a.split(".").length - b.split(".").length);
+            for (const path of sortedPaths) {
+                const config = this.joinRelations.get(path);
+                const columnName = config.alias;
+                const relatedData = record[columnName];
+                delete record[columnName];
+                const parsedData = relatedData !== null &&
+                    !(typeof relatedData === "object" &&
+                        Object.values(relatedData).every((v) => v === null))
+                    ? relatedData
+                    : null;
+                const parts = path.split(".");
+                const lastPart = parts.pop();
+                let current = relationData;
+                for (const part of parts) {
+                    if (!current[part])
+                        current[part] = {};
+                    current = current[part];
                 }
+                current[lastPart] = parsedData;
             }
-            // Functions not preceded by a string are ignored (invalid usage)
-        }
-        return this;
-    }
-    /**
-     * Add a count of related models as a virtual field.
-     * @param relations - Relation name(s) to count
-     */
-    withCount(...relations) {
-        this.countRelations.push(...relations);
-        return this;
-    }
-    /**
-     * Filter results to only those that have related models.
-     * @param relation - Relation name
-     * @param operator - Optional comparison operator
-     * @param count - Optional count to compare against
-     */
-    has(relation, operator, count) {
-        // TODO: Implement has() using EXISTS subquery
-        this.addOperation("has", { relation, operator, count });
-        return this;
-    }
-    /**
-     * Filter results that have related models matching specific conditions.
-     * @param relation - Relation name
-     * @param callback - Callback to define conditions
-     */
-    whereHas(relation, callback) {
-        // TODO: Implement whereHas() using EXISTS subquery with conditions
-        this.addOperation("whereHas", { relation, callback });
-        return this;
+            result.set(index, relationData);
+        });
+        return result;
     }
     /**
-     * Filter results that don't have any related models.
-     * @param relation - Relation name
+     * Attach extracted relation data to hydrated model instances.
      */
-    doesntHave(relation) {
-        // TODO: Implement doesntHave() using NOT EXISTS subquery
-        this.addOperation("doesntHave", { relation });
-        return this;
+    attachJoinedRelations(records, joinedData) {
+        if (this.joinRelations.size === 0)
+            return;
+        const attachNested = (model, dataTree, currentPath = "") => {
+            if (!dataTree || typeof dataTree !== "object")
+                return;
+            for (const [key, data] of Object.entries(dataTree)) {
+                const path = currentPath ? `${currentPath}.${key}` : key;
+                const config = this.joinRelations.get(path);
+                if (!config)
+                    continue;
+                const m = model;
+                if (data === null) {
+                    m[key] = null;
+                    m.loadedRelations?.set(key, null);
+                    continue;
+                }
+                const RelatedModel = registerModel.resolveModelClass(config.model);
+                if (!RelatedModel)
+                    continue;
+                const childKeys = Array.from(this.joinRelations.keys())
+                    .filter((p) => p.startsWith(`${path}.`))
+                    .map((p) => p.split(".")[path.split(".").length]);
+                if (config.type === "hasMany") {
+                    const rows = Array.isArray(data) ? data : [];
+                    const instances = rows.map((row) => {
+                        const rowData = { ...row };
+                        for (const childKey of childKeys)
+                            delete rowData[childKey];
+                        return RelatedModel.hydrate(rowData);
+                    });
+                    m[key] = instances;
+                    m.loadedRelations?.set(key, instances);
+                }
+                else {
+                    const modelData = { ...data };
+                    for (const childKey of childKeys)
+                        delete modelData[childKey];
+                    const relatedInstance = RelatedModel.hydrate(modelData);
+                    attachNested(relatedInstance, data, path);
+                    m[key] = relatedInstance;
+                    m.loadedRelations?.set(key, relatedInstance);
+                }
+            }
+        };
+        records.forEach((model, index) => {
+            const relationData = joinedData.get(index);
+            if (relationData)
+                attachNested(model, relationData);
+        });
     }
+    // ============================================================================
+    // INTERNAL HELPERS
+    // ============================================================================
     /**
-     * Filter results that don't have related models matching specific conditions.
-     * @param relation - Relation name
-     * @param callback - Callback to define conditions
+     * Build a WHERE-only SQL fragment from `where*` operations on the current builder.
+     * Used by DELETE / UPDATE / increment paths.
      */
-    whereDoesntHave(relation, callback) {
-        // TODO: Implement whereDoesntHave() using NOT EXISTS subquery with conditions
-        this.addOperation("whereDoesntHave", { relation, callback });
-        return this;
+    buildFilter() {
+        const whereOps = this.operations.filter((op) => op.type.includes("where") || op.type.includes("Where"));
+        if (whereOps.length === 0)
+            return { sql: "", params: [] };
+        const parser = new postgresQueryParser.PostgresQueryParser({
+            table: this.table,
+            operations: toParserOps(whereOps),
+        });
+        const { query = "", bindings = [] } = parser.parse();
+        const whereMatch = query.match(/WHERE .+$/);
+        return { sql: whereMatch ? whereMatch[0] : "", params: bindings };
     }
 }exports.PostgresQueryBuilder=PostgresQueryBuilder;//# sourceMappingURL=postgres-query-builder.js.map