@warlock.js/cascade 4.0.92 → 4.0.93

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

@@ -0,0 +1,1800 @@
+import {dataSourceRegistry}from'../../data-source/data-source-registry.js';import {getModelFromRegistry}from'../../model/register-model.js';import {PostgresQueryParser}from'./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.
+ *
+ * @module cascade/drivers/postgres
+ */
+/**
+ * PostgreSQL Query Builder.
+ *
+ * Implements the Cascade QueryBuilderContract for PostgreSQL.
+ * Collects query operations and delegates to PostgresQueryParser
+ * for SQL generation.
+ *
+ * @example
+ * ```typescript
+ * const users = await queryBuilder('users')
+ *   .select(['id', 'name', 'email'])
+ *   .where('status', 'active')
+ *   .where('age', '>', 18)
+ *   .orderBy('createdAt', 'desc')
+ *   .limit(10)
+ *   .get();
+ * ```
+ */
+class PostgresQueryBuilder {
+    table;
+    /**
+     * Collected operations to be parsed into SQL.
+     */
+    operations = [];
+    /**
+     * Data source instance.
+     */
+    dataSource;
+    /**
+     * Hydrate callback for transforming results.
+     */
+    hydrateCallback;
+    /**
+     * Callback invoked before query execution.
+     */
+    fetchingCallback;
+    /**
+     * Callback invoked after records fetched but before hydration.
+     */
+    hydratingCallback;
+    /**
+     * Callback invoked after records fetched and hydrated.
+     */
+    fetchedCallback;
+    /**
+     * Pending global scopes.
+     */
+    pendingGlobalScopes;
+    /**
+     * Available local scopes.
+     */
+    availableLocalScopes;
+    /**
+     * Disabled global scope names.
+     */
+    disabledGlobalScopes = new Set();
+    /**
+     * Whether scopes have been applied.
+     */
+    scopesApplied = false;
+    /**
+     * Create a new query builder.
+     *
+     * @param table - Target table name
+     * @param dataSource - Optional data source (uses default if not provided)
+     */
+    constructor(table, dataSource) {
+        this.table = table;
+        this.dataSource = dataSource ?? dataSourceRegistry.get();
+    }
+    /**
+     * Get the PostgreSQL driver instance.
+     */
+    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() {
+        const cloned = new PostgresQueryBuilder(this.table, this.dataSource);
+        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;
+        return cloned;
+    }
+    // ============================================================================
+    // HYDRATION
+    // ============================================================================
+    /**
+     * Set a hydration callback to transform each result row.
+     *
+     * @param callback - Transform function
+     * @returns This builder for chaining
+     */
+    hydrate(callback) {
+        this.hydrateCallback = callback;
+        return this;
+    }
+    /**
+     * Register callback invoked before query execution.
+     *
+     * @param callback - Callback function
+     * @returns Unsubscribe function
+     */
+    onFetching(callback) {
+        this.fetchingCallback = callback;
+        return () => {
+            this.fetchingCallback = undefined;
+        };
+    }
+    /**
+     * Register callback invoked after fetch but before hydration.
+     *
+     * @param callback - Callback function
+     * @returns Unsubscribe function
+     */
+    onHydrating(callback) {
+        this.hydratingCallback = callback;
+        return () => {
+            this.hydratingCallback = undefined;
+        };
+    }
+    /**
+     * Register callback invoked after fetch and hydration.
+     *
+     * @param callback - Callback function
+     * @returns Unsubscribe function
+     */
+    onFetched(callback) {
+        this.fetchedCallback = callback;
+        return () => {
+            this.fetchedCallback = undefined;
+        };
+    }
+    // ============================================================================
+    // 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.
+     */
+    applyPendingScopes() {
+        if (!this.pendingGlobalScopes || this.scopesApplied) {
+            return;
+        }
+        const beforeOps = [];
+        const afterOps = [];
+        for (const [name, { callback, timing }] of this.pendingGlobalScopes) {
+            if (this.disabledGlobalScopes.has(name)) {
+                continue;
+            }
+            const tempBuilder = new PostgresQueryBuilder(this.table, this.dataSource);
+            callback(tempBuilder);
+            if (timing === "before") {
+                beforeOps.push(...tempBuilder.operations);
+            }
+            else {
+                afterOps.push(...tempBuilder.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] });
+        }
+        else if (args.length === 3) {
+            this.addOperation("where", { field: args[0], operator: args[1], value: args[2] });
+        }
+        return this;
+    }
+    orWhere(...args) {
+        if (args.length === 2) {
+            this.addOperation("orWhere", { field: args[0], operator: "=", value: args[1] });
+        }
+        else if (args.length === 3) {
+            this.addOperation("orWhere", { field: args[0], operator: args[1], value: args[2] });
+        }
+        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);
+        }
+        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],
+        });
+        return this;
+    }
+    // ============================================================================
+    // WHERE CLAUSES - CONVENIENCE METHODS
+    // ============================================================================
+    /**
+     * 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 });
+            }
+        }
+        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 {
+                for (const [key, value] of Object.entries(input)) {
+                    this.addOperation("having", { field: key, operator: "=", value });
+                }
+            }
+        }
+        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({
+            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"
+                ? 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);
+                    }
+                    continue;
+                }
+                const relationDef = this.relationDefinitions[relationName];
+                if (!relationDef)
+                    continue;
+                // Resolve and hydrate the related model
+                const RelatedModel = typeof relationDef.model === "string"
+                    ? 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);
+                    }
+                }
+            }
+        });
+    }
+    /**
+     * Get first result.
+     */
+    async first() {
+        const results = await this.limit(1).get();
+        return results[0] ?? null;
+    }
+    /**
+     * Get last result.
+     */
+    async last() {
+        const results = await this.orderByDesc("id").limit(1).get();
+        return results[0] ?? null;
+    }
+    /**
+     * Get random results.
+     */
+    async random(limit) {
+        this.orderByRaw("RANDOM()");
+        if (limit) {
+            this.limit(limit);
+        }
+        return this.get();
+    }
+    /**
+     * Get first or throw.
+     */
+    async firstOrFail() {
+        const result = await this.first();
+        if (!result) {
+            throw new Error("No records found");
+        }
+        return result;
+    }
+    /**
+     * Get first or call callback.
+     */
+    async firstOr(callback) {
+        const result = await this.first();
+        return result ?? (await callback());
+    }
+    /**
+     * Get first or return default.
+     */
+    async firstOrNull() {
+        return this.first();
+    }
+    /**
+     * Get first or create new.
+     */
+    async firstOrNew(defaults) {
+        const result = await this.first();
+        return result ?? defaults;
+    }
+    /**
+     * Find by ID.
+     */
+    async find(id) {
+        return this.where("id", id).first();
+    }
+    /**
+     * Count results.
+     */
+    async count() {
+        this.applyPendingScopes();
+        // Build count query using selectRaw to avoid quoting COUNT(*) as a column
+        const countOps = [
+            ...this.operations.filter((op) => op.type.includes("where") || op.type.includes("join")),
+            { type: "selectRaw", data: { expression: 'COUNT(*) AS "count"' } },
+        ];
+        const parser = new PostgresQueryParser({
+            table: this.table,
+            operations: countOps,
+        });
+        const { sql, params } = parser.parse();
+        const result = await this.driver.query(sql, params);
+        return parseInt(result.rows[0]?.count ?? "0", 10);
+    }
+    /**
+     * Sum of field values.
+     */
+    async sum(field) {
+        this.applyPendingScopes();
+        const result = await this.selectRaw(`SUM(${field}) as sum`).first();
+        return parseFloat(result?.sum ?? "0");
+    }
+    /**
+     * Average of field values.
+     */
+    async avg(field) {
+        this.applyPendingScopes();
+        const result = await this.selectRaw(`AVG(${field}) as avg`).first();
+        return parseFloat(result?.avg ?? "0");
+    }
+    /**
+     * Minimum field value.
+     */
+    async min(field) {
+        this.applyPendingScopes();
+        const result = await this.selectRaw(`MIN(${field}) as min`).first();
+        return parseFloat(result?.min ?? "0");
+    }
+    /**
+     * Maximum field value.
+     */
+    async max(field) {
+        this.applyPendingScopes();
+        const result = await this.selectRaw(`MAX(${field}) as max`).first();
+        return parseFloat(result?.max ?? "0");
+    }
+    /**
+     * Get distinct values.
+     */
+    async distinct(field) {
+        this.distinctValues(field);
+        const results = await this.get();
+        return results.map((row) => row[field]);
+    }
+    /**
+     * Get array of values for field.
+     */
+    async pluck(field) {
+        const results = await this.select([field]).get();
+        return results.map((row) => row[field]);
+    }
+    /**
+     * Get single scalar value.
+     */
+    async value(field) {
+        const result = await this.select([field]).first();
+        return result?.[field] ?? null;
+    }
+    /**
+     * Check if records exist.
+     */
+    async exists() {
+        const count = await this.limit(1).count();
+        return count > 0;
+    }
+    /**
+     * Check if no records exist.
+     */
+    async notExists() {
+        return !(await this.exists());
+    }
+    /**
+     * Count distinct values.
+     */
+    async countDistinct(field) {
+        const result = await this.selectRaw(`COUNT(DISTINCT ${field}) as count`).first();
+        return parseInt(result?.count ?? "0", 10);
+    }
+    /**
+     * Increment field 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]);
+        return result.rows[0]?.[field] ?? 0;
+    }
+    /**
+     * Decrement field value.
+     */
+    async decrement(field, amount = 1) {
+        return this.increment(field, -amount);
+    }
+    /**
+     * Increment for all matching.
+     */
+    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]);
+        return result.rowCount ?? 0;
+    }
+    /**
+     * Decrement for all matching.
+     */
+    async decrementMany(field, amount = 1) {
+        return this.incrementMany(field, -amount);
+    }
+    // ============================================================================
+    // CHUNKING / PAGINATION
+    // ============================================================================
+    /**
+     * Process results in chunks.
+     */
+    async chunk(size, callback) {
+        let chunkIndex = 0;
+        let hasMore = true;
+        while (hasMore) {
+            const chunk = await this.clone()
+                .skip(chunkIndex * size)
+                .limit(size)
+                .get();
+            if (chunk.length === 0) {
+                break;
+            }
+            const shouldContinue = await callback(chunk, chunkIndex);
+            if (shouldContinue === false) {
+                break;
+            }
+            hasMore = chunk.length === size;
+            chunkIndex++;
+        }
+    }
+    /**
+     * Page-based pagination.
+     */
+    async paginate(options) {
+        const page = options.page ?? 1;
+        const limit = options.limit ?? 10;
+        const skip = (page - 1) * limit;
+        const [data, total] = await Promise.all([
+            this.clone().skip(skip).limit(limit).get(),
+            this.count(),
+        ]);
+        return {
+            data,
+            pagination: {
+                total,
+                page,
+                limit,
+                pages: Math.ceil(total / limit),
+            },
+        };
+    }
+    /**
+     * Cursor-based pagination.
+     */
+    async cursorPaginate(options) {
+        const { limit, cursor, column = "id", direction = "next" } = options;
+        if (cursor) {
+            const operator = direction === "next" ? ">" : "<";
+            this.where(column, operator, cursor);
+        }
+        const sortOrder = direction === "next" ? "asc" : "desc";
+        this.orderBy(column, sortOrder);
+        const results = await this.limit(limit + 1).get();
+        const hasMore = results.length > limit;
+        let data = hasMore ? results.slice(0, limit) : results;
+        if (direction === "prev") {
+            data = data.reverse();
+        }
+        let nextCursor;
+        let prevCursor;
+        let hasPrev = false;
+        if (data.length > 0) {
+            const firstItem = data[0][column];
+            const lastItem = data[data.length - 1][column];
+            if (direction === "next") {
+                nextCursor = hasMore ? lastItem : undefined;
+                if (cursor) {
+                    hasPrev = true;
+                    prevCursor = firstItem;
+                }
+            }
+            else {
+                prevCursor = hasMore ? firstItem : undefined;
+                hasPrev = hasMore;
+                if (cursor) {
+                    nextCursor = lastItem;
+                }
+            }
+        }
+        return {
+            data,
+            pagination: {
+                hasMore,
+                hasPrev,
+                nextCursor,
+                prevCursor,
+            },
+        };
+    }
+    // ============================================================================
+    // MUTATION METHODS
+    // ============================================================================
+    /**
+     * Delete matching records.
+     */
+    async delete() {
+        this.applyPendingScopes();
+        const { sql, params } = this.buildFilter();
+        const deleteSql = `DELETE FROM ${this.driver.dialect.quoteIdentifier(this.table)} ${sql}`;
+        const result = await this.driver.query(deleteSql, params);
+        return result.rowCount ?? 0;
+    }
+    /**
+     * Delete first matching record.
+     */
+    async deleteOne() {
+        return this.limit(1).delete();
+    }
+    /**
+     * Update matching records.
+     */
+    async update(fields) {
+        this.applyPendingScopes();
+        const result = await this.driver.updateMany(this.table, {}, { $set: fields });
+        return result.modifiedCount;
+    }
+    /**
+     * Unset fields from matching records.
+     */
+    async unset(...fields) {
+        this.applyPendingScopes();
+        const updateObj = {};
+        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.
+     */
+    parse() {
+        this.applyPendingScopes();
+        const parser = new PostgresQueryParser({
+            table: this.table,
+            operations: this.operations,
+        });
+        return parser.parse();
+    }
+    /**
+     * Get formatted SQL string.
+     */
+    pretty() {
+        const { sql, params } = this.parse();
+        return `${sql}\n-- Parameters: ${JSON.stringify(params)}`;
+    }
+    /**
+     * Get query execution plan.
+     */
+    async explain() {
+        const { sql, params } = this.parse();
+        const explainSql = `EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) ${sql}`;
+        const result = await this.driver.query(explainSql, params);
+        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.
+     */
+    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;
+    }
+    // ============================================================================
+    // INTERNAL HELPERS
+    // ============================================================================
+    /**
+     * Build WHERE clause from current operations.
+     */
+    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({
+            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
+     */
+    joinWith(...relations) {
+        for (const relation of relations) {
+            const def = this.relationDefinitions?.[relation];
+            if (def) {
+                this.joinRelations.set(relation, {
+                    alias: `_rel_${relation}`,
+                    type: def.type,
+                });
+            }
+        }
+        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
+     */
+    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);
+                }
+            }
+            // 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;
+    }
+    /**
+     * Filter results that don't have any related models.
+     * @param relation - Relation name
+     */
+    doesntHave(relation) {
+        // TODO: Implement doesntHave() using NOT EXISTS subquery
+        this.addOperation("doesntHave", { relation });
+        return this;
+    }
+    /**
+     * Filter results that don't have related models matching specific conditions.
+     * @param relation - Relation name
+     * @param callback - Callback to define conditions
+     */
+    whereDoesntHave(relation, callback) {
+        // TODO: Implement whereDoesntHave() using NOT EXISTS subquery with conditions
+        this.addOperation("whereDoesntHave", { relation, callback });
+        return this;
+    }
+}export{PostgresQueryBuilder};//# sourceMappingURL=postgres-query-builder.js.map