@warlock.js/cascade 4.0.174 → 4.1.2

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

@@ -1,868 +0,0 @@
-'use strict';var postgresDialect=require('./postgres-dialect.js');/**
- * PostgreSQL Query Parser
- *
- * Translates Cascade query operations into PostgreSQL SQL queries.
- * Mirrors the MongoQueryParser pattern but generates SQL instead
- * of MongoDB aggregation pipelines.
- *
- * @module cascade/drivers/postgres
- */
-/**
- * PostgreSQL Query Parser.
- *
- * Converts a list of query operations into a SQL query string with parameters.
- * Handles SELECT, WHERE, JOIN, ORDER BY, GROUP BY, LIMIT/OFFSET clauses.
- *
- * @example
- * ```typescript
- * const parser = new PostgresQueryParser({
- *   table: 'users',
- *   operations: [
- *     { type: 'where', data: { field: 'name', operator: '=', value: 'Alice' } },
- *     { type: 'orderBy', data: { field: 'createdAt', direction: 'desc' } },
- *     { type: 'limit', data: { value: 10 } }
- *   ]
- * });
- *
- * const { sql, params } = parser.parse();
- * // sql: 'SELECT * FROM "users" WHERE "name" = $1 ORDER BY "createdAt" DESC LIMIT 10'
- * // params: ['Alice']
- * ```
- */
-class PostgresQueryParser {
-    /**
-     * Target table name.
-     */
-    table;
-    /**
-     * Table alias.
-     */
-    alias;
-    /**
-     * Operations to process.
-     */
-    operations;
-    /**
-     * SQL dialect for syntax.
-     */
-    dialect;
-    /**
-     * Current parameter index (1-based for PostgreSQL).
-     */
-    paramIndex = 1;
-    /**
-     * Collected parameters.
-     */
-    params = [];
-    /**
-     * SELECT columns.
-     */
-    selectColumns = [];
-    /**
-     * Deselected (excluded) columns.
-     */
-    deselectColumns = [];
-    /**
-     * Raw SELECT expressions.
-     */
-    selectRaw = [];
-    /**
-     * WHERE clauses.
-     */
-    whereClauses = [];
-    /**
-     * JOIN clauses.
-     */
-    joinClauses = [];
-    /**
-     * ORDER BY clauses.
-     */
-    orderClauses = [];
-    /**
-     * GROUP BY columns.
-     */
-    groupColumns = [];
-    /**
-     * HAVING clauses.
-     */
-    havingClauses = [];
-    /**
-     * LIMIT value.
-     */
-    limitValue;
-    /**
-     * OFFSET value.
-     */
-    offsetValue;
-    /**
-     * DISTINCT flag.
-     */
-    isDistinct = false;
-    /**
-     * Whether the query has any JOIN operations (pre-scanned before processing).
-     * Used by qualifyColumn() to decide whether to prefix columns with the main table.
-     */
-    hasJoins = false;
-    /**
-     * Tracked joined tables (for table reference detection).
-     */
-    joinedTables = new Set();
-    /**
-     * Create a new query parser.
-     *
-     * @param options - Parser configuration
-     */
-    constructor(options) {
-        this.table = options.table;
-        this.alias = options.alias;
-        this.operations = options.operations;
-        this.dialect = options.dialect ?? new postgresDialect.PostgresDialect();
-    }
-    /**
-     * Parse all operations and build the SQL query.
-     *
-     * @returns DriverQuery with `query` (SQL string) and `bindings` (parameter values)
-     */
-    parse() {
-        // Pre-scan for any join operations so qualifyColumn() can prefix columns
-        // correctly even when WHERE clauses appear before JOINs in the operations list.
-        const JOIN_TYPES = new Set([
-            "join",
-            "leftJoin",
-            "rightJoin",
-            "innerJoin",
-            "fullJoin",
-            "crossJoin",
-            "joinRaw",
-        ]);
-        this.hasJoins = false;
-        // First pass: locate all joins and populate joinedTables for accurate JSON path detection
-        for (const operation of this.operations) {
-            if (JOIN_TYPES.has(operation.type)) {
-                this.hasJoins = true;
-                const data = operation.data;
-                const joinTable = data.table;
-                const alias = data.alias;
-                if (joinTable)
-                    this.joinedTables.add(joinTable);
-                if (alias)
-                    this.joinedTables.add(alias);
-            }
-        }
-        // Process each operation
-        for (const operation of this.operations) {
-            this.processOperation(operation);
-        }
-        // Build the final SQL query
-        const query = this.buildSql();
-        return { query, bindings: this.params };
-    }
-    /**
-     * Get a formatted string representation of the query.
-     *
-     * @returns Formatted SQL with bindings
-     */
-    toPrettyString() {
-        const { query = "", bindings } = this.parse();
-        return `${query}\n-- Bindings: ${JSON.stringify(bindings ?? [])}`;
-    }
-    /**
-     * Process a single operation.
-     *
-     * @param operation - The operation to process
-     */
-    processOperation(operation) {
-        const { type, data } = operation;
-        switch (type) {
-            // WHERE operations
-            case "where":
-                this.processWhere(data, "AND");
-                break;
-            case "orWhere":
-                this.processWhere(data, "OR");
-                break;
-            case "whereRaw":
-                this.processWhereRaw(data, "AND");
-                break;
-            case "orWhereRaw":
-                this.processWhereRaw(data, "OR");
-                break;
-            case "whereIn":
-                this.processWhereIn(data, false);
-                break;
-            case "whereNotIn":
-                this.processWhereIn(data, true);
-                break;
-            case "whereNull":
-                this.processWhereNull(data, false);
-                break;
-            case "whereNotNull":
-                this.processWhereNull(data, true);
-                break;
-            case "whereBetween":
-                this.processWhereBetween(data, false);
-                break;
-            case "whereNotBetween":
-                this.processWhereBetween(data, true);
-                break;
-            case "whereLike":
-                this.processWhereLike(data, false);
-                break;
-            case "whereNotLike":
-                this.processWhereLike(data, true);
-                break;
-            case "whereColumn":
-                this.processWhereColumn(data, "AND");
-                break;
-            case "orWhereColumn":
-                this.processWhereColumn(data, "OR");
-                break;
-            case "whereJsonContains":
-                this.processWhereJsonContains(data, false);
-                break;
-            case "whereJsonDoesntContain":
-                this.processWhereJsonContains(data, true);
-                break;
-            case "whereFullText":
-                this.processWhereFullText(data);
-                break;
-            // SELECT operations
-            case "select":
-                this.processSelect(data);
-                break;
-            case "selectRaw":
-                this.processSelectRaw(data);
-                break;
-            case "deselect":
-                this.processDeselect(data);
-                break;
-            // JOIN operations
-            case "join":
-            case "innerJoin":
-                this.processJoin(data, "INNER");
-                break;
-            case "leftJoin":
-                this.processJoin(data, "LEFT");
-                break;
-            case "rightJoin":
-                this.processJoin(data, "RIGHT");
-                break;
-            case "fullJoin":
-                this.processJoin(data, "FULL OUTER");
-                break;
-            case "crossJoin":
-                this.processCrossJoin(data);
-                break;
-            case "joinRaw":
-                this.processJoinRaw(data);
-                break;
-            // ORDER operations
-            case "orderBy":
-                this.processOrderBy(data);
-                break;
-            case "orderByRaw":
-                this.processOrderByRaw(data);
-                break;
-            // GROUP operations
-            case "groupBy":
-                this.processGroupBy(data);
-                break;
-            case "having":
-                this.processHaving(data);
-                break;
-            case "havingRaw":
-                this.processHavingRaw(data);
-                break;
-            // LIMIT operations
-            case "limit":
-                this.limitValue = data.value;
-                break;
-            case "offset":
-                this.offsetValue = data.value;
-                break;
-            // Other
-            case "distinct":
-                this.isDistinct = true;
-                break;
-            // joinWith select related columns
-            case "selectRelatedColumns":
-                this.processSelectRelatedColumns(data);
-                break;
-        }
-    }
-    /**
-     * Build the final SQL query from collected clauses.
-     *
-     * @returns Complete SQL query string
-     */
-    buildSql() {
-        const parts = [];
-        // SELECT clause
-        parts.push(this.buildSelectClause());
-        // FROM clause
-        const quotedTable = this.dialect.quoteIdentifier(this.table);
-        const fromClause = this.alias
-            ? `FROM ${quotedTable} AS ${this.dialect.quoteIdentifier(this.alias)}`
-            : `FROM ${quotedTable}`;
-        parts.push(fromClause);
-        // JOIN clauses
-        if (this.joinClauses.length > 0) {
-            parts.push(this.joinClauses.join(" "));
-        }
-        // WHERE clause
-        if (this.whereClauses.length > 0) {
-            parts.push(`WHERE ${this.whereClauses.join(" ")}`);
-        }
-        // GROUP BY clause
-        if (this.groupColumns.length > 0) {
-            const quotedCols = this.groupColumns.map((c) => this.dialect.quoteIdentifier(c));
-            parts.push(`GROUP BY ${quotedCols.join(", ")}`);
-        }
-        // HAVING clause
-        if (this.havingClauses.length > 0) {
-            parts.push(`HAVING ${this.havingClauses.join(" AND ")}`);
-        }
-        // ORDER BY clause
-        if (this.orderClauses.length > 0) {
-            parts.push(`ORDER BY ${this.orderClauses.join(", ")}`);
-        }
-        // LIMIT/OFFSET
-        const limitOffset = this.dialect.limitOffset(this.limitValue, this.offsetValue);
-        if (limitOffset) {
-            parts.push(limitOffset);
-        }
-        return parts.join(" ");
-    }
-    /**
-     * Build the SELECT clause.
-     *
-     * @returns SELECT clause string
-     */
-    buildSelectClause() {
-        const distinct = this.isDistinct ? "DISTINCT " : "";
-        // If no specific columns, select all — qualify with main table when joins present
-        if (this.selectColumns.length === 0 && this.selectRaw.length === 0) {
-            return this.hasJoins
-                ? `SELECT ${distinct}${this.dialect.quoteIdentifier(this.table)}.*`
-                : `SELECT ${distinct}*`;
-        }
-        const columns = [];
-        // Add selected columns — prefix with main table when joins present to avoid ambiguity
-        for (const col of this.selectColumns) {
-            if (!this.deselectColumns.includes(col)) {
-                columns.push(this.parseColumnIdentifier(col, this.table, this.alias));
-            }
-        }
-        // Add raw expressions
-        columns.push(...this.selectRaw);
-        return `SELECT ${distinct}${columns.join(", ")}`;
-    }
-    /**
-     * Add a placeholder and parameter.
-     *
-     * @param value - Parameter value
-     * @returns Placeholder string ($1, $2, etc.)
-     */
-    addParam(value) {
-        this.params.push(value);
-        return this.dialect.placeholder(this.paramIndex++);
-    }
-    /**
-     * Process a basic WHERE operation.
-     *
-     * Delegates to specialised processors for operators that require more than a
-     * single placeholder (between, in, like-variants, exists, etc.).
-     */
-    processWhere(data, boolean) {
-        const field = data.field;
-        const operator = data.operator ?? "=";
-        const value = data.value;
-        // Delegate to specialised processors for operators that need it
-        switch (operator) {
-            case "between":
-                return this.processWhereBetween({ field, range: value }, false);
-            case "notBetween":
-                return this.processWhereBetween({ field, range: value }, true);
-            case "in":
-                return this.processWhereIn({ field, values: value }, false);
-            case "notIn":
-                return this.processWhereIn({ field, values: value }, true);
-            case "like":
-            case "ilike":
-            case "startsWith":
-            case "endsWith":
-                return this.processWhereLike({ field, pattern: value }, false);
-            case "notLike":
-            case "notStartsWith":
-            case "notEndsWith":
-                return this.processWhereLike({ field, pattern: value }, true);
-            case "exists":
-                // EXISTS expects value to be a raw sub-query string
-                return this.addWhereClause(`EXISTS (${value})`, boolean);
-        }
-        const quotedField = this.parseColumnIdentifier(field, this.table, this.alias);
-        if (value === null) {
-            const nullOperator = operator === "!=" ? "IS NOT NULL" : "IS NULL";
-            return this.addWhereClause(`${quotedField} ${nullOperator}`, boolean);
-        }
-        // Simple single-value operator — fall through to generic path
-        const placeholder = this.addParam(value);
-        this.addWhereClause(`${quotedField} ${this.mapOperator(operator)} ${placeholder}`, boolean);
-    }
-    /**
-     * Process a raw WHERE operation.
-     */
-    processWhereRaw(data, boolean) {
-        const expression = data.expression;
-        const bindings = data.bindings ?? [];
-        // Replace ? placeholders with $n
-        let processed = expression;
-        for (const binding of bindings) {
-            processed = processed.replace("?", this.addParam(binding));
-        }
-        this.addWhereClause(processed, boolean);
-    }
-    /**
-     * Process WHERE IN / NOT IN.
-     */
-    processWhereIn(data, negate) {
-        const field = data.field;
-        const values = data.values;
-        const quotedField = this.parseColumnIdentifier(field, this.table, this.alias);
-        const operator = negate ? "!= ALL" : "= ANY";
-        const placeholder = this.addParam(values);
-        this.addWhereClause(`${quotedField} ${operator}(${placeholder})`, "AND");
-    }
-    /**
-     * Process WHERE NULL / NOT NULL.
-     */
-    processWhereNull(data, negate) {
-        const field = data.field;
-        const quotedField = this.parseColumnIdentifier(field, this.table, this.alias);
-        const clause = negate ? `${quotedField} IS NOT NULL` : `${quotedField} IS NULL`;
-        this.addWhereClause(clause, "AND");
-    }
-    /**
-     * Process WHERE BETWEEN / NOT BETWEEN.
-     */
-    processWhereBetween(data, negate) {
-        const field = data.field;
-        const range = data.range;
-        const quotedField = this.parseColumnIdentifier(field, this.table, this.alias);
-        const placeholder1 = this.addParam(range[0]);
-        const placeholder2 = this.addParam(range[1]);
-        const keyword = negate ? "NOT BETWEEN" : "BETWEEN";
-        this.addWhereClause(`${quotedField} ${keyword} ${placeholder1} AND ${placeholder2}`, "AND");
-    }
-    /**
-     * Process WHERE LIKE / NOT LIKE.
-     */
-    processWhereLike(data, negate) {
-        const field = data.field;
-        const pattern = data.pattern;
-        const quotedField = this.parseColumnIdentifier(field, this.table, this.alias);
-        const { operator } = this.dialect.likePattern(pattern, true);
-        const placeholder = this.addParam(pattern);
-        const keyword = negate ? `NOT ${operator}` : operator;
-        this.addWhereClause(`${quotedField} ${keyword} ${placeholder}`, "AND");
-    }
-    /**
-     * Process WHERE column comparison.
-     */
-    processWhereColumn(data, boolean) {
-        const first = data.first;
-        const operator = data.operator ?? "=";
-        const second = data.second;
-        // Both sides may need qualification if unambiguous table is unclear
-        const quotedFirst = this.parseColumnIdentifier(first, this.table, this.alias);
-        const quotedSecond = this.parseColumnIdentifier(second, this.table, this.alias);
-        this.addWhereClause(`${quotedFirst} ${operator} ${quotedSecond}`, boolean);
-    }
-    /**
-     * Process WHERE JSON contains.
-     */
-    processWhereJsonContains(data, negate) {
-        const path = data.path;
-        const value = data.value;
-        const quotedPath = this.parseColumnIdentifier(path, this.table, this.alias);
-        const jsonValue = JSON.stringify(value);
-        const operator = negate ? "NOT @>" : "@>";
-        this.addWhereClause(`${quotedPath} ${operator} '${jsonValue}'::jsonb`, "AND");
-    }
-    /**
-     * Process full-text search WHERE.
-     */
-    processWhereFullText(data) {
-        const fields = data.fields;
-        const query = data.query;
-        // Build tsvector from fields
-        const tsVectors = fields
-            .map((f) => `to_tsvector('english', ${this.dialect.quoteIdentifier(f)})`)
-            .join(" || ");
-        const placeholder = this.addParam(query);
-        this.addWhereClause(`(${tsVectors}) @@ plainto_tsquery('english', ${placeholder})`, "AND");
-    }
-    /**
-     * Process SELECT operation.
-     */
-    processSelect(data) {
-        const fields = data.fields;
-        if (Array.isArray(fields)) {
-            this.selectColumns.push(...fields);
-        }
-        else {
-            // Handle aliases: { field: 'alias' }
-            for (const [field, alias] of Object.entries(fields)) {
-                const quotedField = this.dialect.quoteIdentifier(field);
-                const quotedAlias = this.dialect.quoteIdentifier(alias);
-                this.selectRaw.push(`${quotedField} AS ${quotedAlias}`);
-            }
-        }
-    }
-    /**
-     * Process raw SELECT expression.
-     */
-    processSelectRaw(data) {
-        const expression = data.expression;
-        const bindings = data.bindings ?? [];
-        if (typeof expression === "string") {
-            // Replace ? placeholders with $n positional params (same as processWhereRaw)
-            let processed = expression;
-            for (const binding of bindings) {
-                processed = processed.replace("?", this.addParam(binding));
-            }
-            this.selectRaw.push(processed);
-        }
-        else {
-            // Handle object expressions (for compatibility)
-            for (const [alias, expr] of Object.entries(expression)) {
-                this.selectRaw.push(`${expr} AS ${this.dialect.quoteIdentifier(alias)}`);
-            }
-        }
-    }
-    /**
-     * Process DESELECT operation.
-     */
-    processDeselect(data) {
-        const fields = data.fields;
-        this.deselectColumns.push(...fields);
-    }
-    /**
-     * Process SELECT for related columns (joinWith).
-     *
-     * - hasOne / belongsTo  → LEFT JOIN + row_to_json  (single object)
-     * - hasMany             → correlated subquery with json_agg (array, no row explosion)
-     *
-     * @example hasMany correlated subquery:
-     *   (SELECT json_agg(row_to_json(a.*))
-     *    FROM "chat_message_actions" a
-     *    WHERE a."chat_message_id" = "chat_messages"."id") AS "actions"
-     *
-     * @example hasOne/belongsTo row_to_json:
-     *   row_to_json("organizationAiModel".*) AS "organizationAiModel"
-     */
-    processSelectRelatedColumns(data) {
-        const alias = data.alias;
-        const select = data.select;
-        const relationType = data.type;
-        const constraintOps = data.constraintOps;
-        const quotedAlias = this.dialect.quoteIdentifier(alias);
-        const quotedTable = this.dialect.quoteIdentifier(this.table);
-        const hasExplicitSelect = this.selectColumns.length > 0;
-        if (!hasExplicitSelect && !this.selectRaw.includes(`${quotedTable}.*`)) {
-            this.selectRaw.unshift(`${quotedTable}.*`);
-        }
-        if (relationType === "hasMany") {
-            // Correlated subquery — no JOIN, no row explosion, returns a JSON array.
-            const relatedTable = data.table;
-            const foreignKey = data.foreignKey;
-            const localKey = data.localKey;
-            const quotedRelatedTable = this.dialect.quoteIdentifier(relatedTable);
-            const quotedForeignKey = this.dialect.quoteIdentifier(foreignKey);
-            const quotedLocalKey = this.dialect.quoteIdentifier(localKey);
-            const quotedMainTable = this.dialect.quoteIdentifier(this.table);
-            let innerSelect;
-            if (select && select.length > 0) {
-                // Pick specific columns: json_agg(json_build_object('id', a."id", ...))
-                const fields = select
-                    .map((col) => `'${col}', a.${this.dialect.quoteIdentifier(col)}`)
-                    .join(", ");
-                innerSelect = `json_agg(json_build_object(${fields}))`;
-            }
-            else {
-                innerSelect = `json_agg(row_to_json(a.*))`;
-            }
-            // Build the base FK condition
-            const fkCondition = `a.${quotedForeignKey} = ${quotedMainTable}.${quotedLocalKey}`;
-            // Merge constraint ops (where / order / limit) from a sub-parser
-            let extraWhere = "";
-            let orderBy = "";
-            let limitClause = "";
-            if (constraintOps && constraintOps.length > 0) {
-                const subParser = new PostgresQueryParser({
-                    table: relatedTable,
-                    alias: "a",
-                    operations: constraintOps,
-                });
-                subParser.parse();
-                if (subParser.whereClauses.length > 0) {
-                    extraWhere = ` AND ${subParser.whereClauses.join(" ")}`;
-                }
-                if (subParser.orderClauses.length > 0) {
-                    orderBy = ` ORDER BY ${subParser.orderClauses.join(", ")}`;
-                }
-                if (subParser.limitValue !== undefined) {
-                    limitClause = ` LIMIT ${subParser.limitValue}`;
-                }
-            }
-            // Wrap with ORDER/LIMIT only when constraints are present (json_agg ignores ORDER)
-            orderBy || limitClause
-                ? `SELECT row_to_json(sub.*) FROM (SELECT * FROM ${quotedRelatedTable} a WHERE ${fkCondition}${extraWhere}${orderBy}${limitClause}) sub`
-                : `SELECT ${innerSelect.replace("json_agg(", "").replace(/\)$/, "")} FROM ${quotedRelatedTable} a WHERE ${fkCondition}${extraWhere}`;
-            const aggregated = orderBy || limitClause
-                ? `(SELECT json_agg(row_to_json(sub.*)) FROM (SELECT * FROM ${quotedRelatedTable} a WHERE ${fkCondition}${extraWhere}${orderBy}${limitClause}) sub) AS ${quotedAlias}`
-                : `(SELECT ${innerSelect} FROM ${quotedRelatedTable} a WHERE ${fkCondition}${extraWhere}) AS ${quotedAlias}`;
-            this.selectRaw.push(aggregated);
-        }
-        else {
-            // hasOne / belongsTo — single object via LEFT JOIN + row_to_json.
-            // If constraint provides an explicit select list, prefer it over data.select
-            let effectiveSelect = select;
-            if (constraintOps && constraintOps.length > 0) {
-                const subParser = new PostgresQueryParser({
-                    table: data.table ?? alias,
-                    alias,
-                    operations: constraintOps,
-                });
-                subParser.parse();
-                if (subParser.selectColumns.length > 0) {
-                    effectiveSelect = subParser.selectColumns;
-                }
-            }
-            if (effectiveSelect && effectiveSelect.length > 0) {
-                const selectedColumns = effectiveSelect
-                    .map((col) => `${quotedAlias}.${this.dialect.quoteIdentifier(col)}`)
-                    .join(", ");
-                this.selectRaw.push(`row_to_json((SELECT d FROM (SELECT ${selectedColumns}) d)) AS ${quotedAlias}`);
-            }
-            else {
-                this.selectRaw.push(`row_to_json(${quotedAlias}.*) AS ${quotedAlias}`);
-            }
-        }
-    }
-    /**
-     * Process JOIN operation with smart field detection.
-     *
-     * Handles both regular columns and JSONB nested paths:
-     * - "id" → "table"."id" (auto-prefixed)
-     * - "users.id" → "users"."id" (explicit table)
-     * - "createdBy.id" → "table"."createdBy"->>'id' (JSONB path)
-     * - "posts.createdBy.id" → "posts"."createdBy"->>'id' (JSONB with table)
-     */
-    processJoin(data, type) {
-        const options = data;
-        const joinTable = "table" in options ? options.table : "";
-        const localField = "localField" in options ? options.localField : "";
-        const foreignField = "foreignField" in options ? options.foreignField : "";
-        const alias = "alias" in options ? options.alias : undefined;
-        const quotedTable = this.dialect.quoteIdentifier(joinTable);
-        const tableRef = alias
-            ? `${quotedTable} AS ${this.dialect.quoteIdentifier(alias)}`
-            : quotedTable;
-        const tableAlias = alias ?? joinTable;
-        // Track the joined table for reference detection
-        this.joinedTables.add(joinTable);
-        if (alias) {
-            this.joinedTables.add(alias);
-        }
-        // Parse local field (belongs to main table)
-        const quotedLocal = this.parseColumnIdentifier(localField, this.table, this.alias);
-        // Parse foreign field (belongs to join table)
-        const quotedForeign = this.parseColumnIdentifier(foreignField, joinTable, tableAlias);
-        this.joinClauses.push(`${type} JOIN ${tableRef} ON ${quotedLocal} = ${quotedForeign}`);
-    }
-    /**
-     * Parse a column identifier with smart detection for table prefixes and JSONB paths.
-     *
-     * @param field - The field string (e.g., "id", "users.id", "createdBy.id")
-     * @param defaultTable - Default table to use if no prefix
-     * @param tableAlias - Table alias to use if provided
-     * @returns Properly quoted SQL expression
-     */
-    parseColumnIdentifier(field, defaultTable, tableAlias) {
-        if (!field)
-            return "";
-        const effectiveTable = tableAlias ?? defaultTable;
-        const parts = field.split(".");
-        // Single part: just a column name, prefix with default table
-        if (parts.length === 1) {
-            return `${this.dialect.quoteIdentifier(effectiveTable)}.${this.dialect.quoteIdentifier(field)}`;
-        }
-        // Two parts: could be "table.column" or "jsonbColumn.key"
-        if (parts.length === 2) {
-            const [first, second] = parts;
-            // Check if first part is a known table (main table, join table, or alias)
-            if (this.isTableReference(first)) {
-                // It's table.column - regular column reference
-                return `${this.dialect.quoteIdentifier(first)}.${this.dialect.quoteIdentifier(second)}`;
-            }
-            // It's jsonbColumn.key - JSONB path
-            return this.buildJsonbPath(effectiveTable, first, [second]);
-        }
-        // Three or more parts: "table.jsonbColumn.key..." or "jsonbColumn.key1.key2..."
-        const [first, second, ...rest] = parts;
-        if (this.isTableReference(first)) {
-            // First part is table: "posts.createdBy.id" → table is "posts", JSONB is "createdBy.id"
-            return this.buildJsonbPath(first, second, rest);
-        }
-        // No table prefix: "createdBy.address.city" → use default table
-        return this.buildJsonbPath(effectiveTable, first, [second, ...rest]);
-    }
-    /**
-     * Check if a string is a table reference (main table or join table).
-     */
-    isTableReference(name) {
-        if (name === this.table || name === this.alias) {
-            return true;
-        }
-        if (this.joinedTables.has(name)) {
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Build a JSONB path expression.
-     *
-     * @param table - Table name
-     * @param column - JSONB column name
-     * @param path - Array of nested keys
-     * @returns PostgreSQL JSONB path expression
-     *
-     * @example
-     * buildJsonbPath("posts", "createdBy", ["id"])
-     * // Returns: ("posts"."createdBy"->>'id')::integer
-     *
-     * buildJsonbPath("posts", "createdBy", ["address", "city"])
-     * // Returns: "posts"."createdBy"->'address'->>'city'
-     */
-    buildJsonbPath(table, column, path) {
-        const quotedTable = this.dialect.quoteIdentifier(table);
-        const quotedColumn = this.dialect.quoteIdentifier(column);
-        if (path.length === 0) {
-            return `${quotedTable}.${quotedColumn}`;
-        }
-        // Build JSONB path: use -> for intermediate keys, ->> for final key (returns text)
-        let expression = `${quotedTable}.${quotedColumn}`;
-        for (let i = 0; i < path.length; i++) {
-            const isLast = i === path.length - 1;
-            const operator = isLast ? "->>" : "->";
-            expression += `${operator}'${path[i]}'`;
-        }
-        // Cast to integer if the path ends with 'id' (common pattern for foreign keys)
-        const lastKey = path[path.length - 1].toLowerCase();
-        if (lastKey === "id" || lastKey.endsWith("id")) {
-            expression = `(${expression})::integer`;
-        }
-        return expression;
-    }
-    /**
-     * Process CROSS JOIN operation.
-     */
-    processCrossJoin(data) {
-        const table = data.table;
-        const quotedTable = this.dialect.quoteIdentifier(table);
-        this.joinClauses.push(`CROSS JOIN ${quotedTable}`);
-    }
-    /**
-     * Process raw JOIN expression.
-     */
-    processJoinRaw(data) {
-        const expression = data.expression;
-        const bindings = data.bindings ?? [];
-        let processed = expression;
-        for (const binding of bindings) {
-            processed = processed.replace("?", this.addParam(binding));
-        }
-        this.joinClauses.push(processed);
-    }
-    /**
-     * Process ORDER BY operation.
-     */
-    processOrderBy(data) {
-        const field = data.field;
-        const direction = (data.direction ?? "asc").toUpperCase();
-        const quotedField = this.parseColumnIdentifier(field, this.table, this.alias);
-        this.orderClauses.push(`${quotedField} ${direction}`);
-    }
-    /**
-     * Process raw ORDER BY expression.
-     */
-    processOrderByRaw(data) {
-        const expression = data.expression;
-        const bindings = data.bindings ?? [];
-        // Replace ? placeholders with $n positional params (same as processWhereRaw)
-        let processed = expression;
-        for (const binding of bindings) {
-            processed = processed.replace("?", this.addParam(binding));
-        }
-        this.orderClauses.push(processed);
-    }
-    /**
-     * Process GROUP BY operation.
-     */
-    processGroupBy(data) {
-        const fields = data.fields;
-        const columns = Array.isArray(fields) ? fields : [fields];
-        this.groupColumns.push(...columns);
-    }
-    /**
-     * Process HAVING operation.
-     */
-    processHaving(data) {
-        const field = data.field;
-        const operator = data.operator ?? "=";
-        const value = data.value;
-        const quotedField = this.dialect.quoteIdentifier(field);
-        const placeholder = this.addParam(value);
-        this.havingClauses.push(`${quotedField} ${operator} ${placeholder}`);
-    }
-    /**
-     * Process raw HAVING expression.
-     */
-    processHavingRaw(data) {
-        const expression = data.expression;
-        this.havingClauses.push(expression);
-    }
-    /**
-     * Add a WHERE clause with boolean operator.
-     */
-    addWhereClause(clause, boolean) {
-        if (this.whereClauses.length === 0) {
-            this.whereClauses.push(clause);
-        }
-        else {
-            this.whereClauses.push(`${boolean} ${clause}`);
-        }
-    }
-    /**
-     * Map simple Cascade operators to their SQL equivalents.
-     *
-     * Complex operators (between, in, like-variants, exists) are handled by
-     * dedicated processors and should never reach this method.
-     */
-    mapOperator(operator) {
-        const mapping = {
-            "=": "=",
-            "!=": "!=",
-            "<>": "<>",
-            ">": ">",
-            ">=": ">=",
-            "<": "<",
-            "<=": "<=",
-            like: "LIKE",
-            notlike: "NOT LIKE",
-            ilike: "ILIKE",
-        };
-        return mapping[operator.toLowerCase()] ?? operator;
-    }
-}exports.PostgresQueryParser=PostgresQueryParser;//# sourceMappingURL=postgres-query-parser.js.map