neoorm 0.7.3 → 0.8.0

package/dist/runtime/query/compile-where.js

@@ -0,0 +1,708 @@
+import { effectiveRelations } from "../../codegen/manifest-relations.js";
+import { postgresDialect, quoteIdentifier, tableRef, } from "../../dialect/postgres.js";
+import { getColumnType } from "../../plugins/registry.js";
+import { compileError } from "../compile-error.js";
+import { QueryErrorCode } from "../error-codes.js";
+import { didYouMean, suggestWhereOperator } from "../error-hints.js";
+import { findM2M } from "./manifest-lookup.js";
+import { primaryKeySqlName, requireScalarPrimaryKey, targetRelationPkSql, } from "./primary-key.js";
+import { columnByTsName, columnsByTsNames, getOrSetSqlCache, getTableIndex, requireTsColumn, } from "./table-index.js";
+export function colByTs(table, tsName, manifestIndex) {
+    return columnByTsName(getTableIndex(manifestIndex, table.accessor), table, tsName);
+}
+function compiledResult(sql, params, nextParamIndex, impossible = false) {
+    return {
+        sql,
+        params,
+        nextParamIndex,
+        ...(impossible ? { impossible: true } : {}),
+    };
+}
+const PARAMLESS_OPERATORS = new Set(["isNull", "isNotNull"]);
+export function isOperatorObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        !(value instanceof Date));
+}
+const operatorParamTransform = {
+    contains: (v) => `%${String(v)}%`,
+    startsWith: (v) => `${String(v)}%`,
+    endsWith: (v) => `%${String(v)}`,
+};
+function parseQueryMode(value) {
+    if (value === undefined || value === "default")
+        return "default";
+    if (value === "insensitive")
+        return "insensitive";
+    compileError(`unsupported query mode: ${String(value)}`);
+}
+function isStringPatternOp(op) {
+    return (op === "equals" ||
+        op === "contains" ||
+        op === "startsWith" ||
+        op === "endsWith" ||
+        op === "search");
+}
+function stringFilterSql(op, sqlCol, paramIndex, mode, dialect) {
+    switch (op) {
+        case "equals":
+            return mode === "insensitive"
+                ? dialect.ilike(sqlCol, paramIndex)
+                : dialect.whereOperators.equals(sqlCol, paramIndex);
+        case "contains":
+        case "startsWith":
+        case "endsWith":
+            return mode === "insensitive"
+                ? dialect.ilike(sqlCol, paramIndex)
+                : dialect.whereOperators[op](sqlCol, paramIndex);
+        case "search":
+            return dialect.regex(sqlCol, paramIndex, mode === "insensitive");
+        default: {
+            const _never = op;
+            compileError(`unsupported string filter: ${_never}`);
+        }
+    }
+}
+function pluginWhereOperators(col) {
+    if (col.kind === "fk")
+        return {};
+    return getColumnType(col.kind)?.whereOperators ?? {};
+}
+export function serializeColumnValue(col, value, dialect = postgresDialect) {
+    if (col.kind === "fk")
+        return value;
+    const plugin = getColumnType(col.kind);
+    if (plugin?.serializeValue) {
+        return plugin.serializeValue(col, value, dialect);
+    }
+    return value;
+}
+function defaultColumnRef(col) {
+    return quoteIdentifier(col.sqlName);
+}
+function qualifiedColumnRefForTable(table) {
+    return (col) => `${tableRef(table)}.${quoteIdentifier(col.sqlName)}`;
+}
+function parentPkRef(table) {
+    const pkSql = primaryKeySqlName(table);
+    return `${tableRef(table)}.${quoteIdentifier(pkSql)}`;
+}
+function knownWhereOperatorNames(col, dialect) {
+    return [
+        ...Object.keys(dialect.whereOperators),
+        ...Object.keys(pluginWhereOperators(col)),
+    ];
+}
+function throwUnsupportedWhereOperator(op, col, operators) {
+    compileError(`unsupported where operator "${op}" on column "${col.tsName}"`, {
+        code: QueryErrorCode.invalid_args,
+        columnTsName: col.tsName,
+        suggestions: suggestWhereOperator(op, operators),
+    });
+}
+function compileColumnCondition(col, rawValue, dialect, paramIndex, columnRef) {
+    const sqlCol = columnRef(col);
+    const spatialOps = pluginWhereOperators(col);
+    const conditions = [];
+    const params = [];
+    let nextParamIndex = paramIndex;
+    let impossible = false;
+    if (rawValue === null) {
+        conditions.push(dialect.whereOperators.isNull(sqlCol, nextParamIndex));
+        return { sql: conditions.join(" AND "), params, nextParamIndex };
+    }
+    if (!isOperatorObject(rawValue) || Array.isArray(rawValue)) {
+        conditions.push(dialect.whereOperators.equals(sqlCol, nextParamIndex));
+        params.push(serializeColumnValue(col, rawValue, dialect));
+        nextParamIndex++;
+        return { sql: conditions.join(" AND "), params, nextParamIndex };
+    }
+    const queryMode = parseQueryMode(rawValue.mode);
+    const knownOps = knownWhereOperatorNames(col, dialect);
+    const knownOpSet = new Set(knownOps);
+    const operatorKeys = Object.keys(rawValue).filter((key) => key !== "mode");
+    const knownKeys = operatorKeys.filter((key) => knownOpSet.has(key));
+    const unknownKeys = operatorKeys.filter((key) => !knownOpSet.has(key));
+    if (knownKeys.length === 0) {
+        if (operatorKeys.length > 0) {
+            const jsonColumn = col.kind === "json" || col.kind === "jsonb";
+            const typo = unknownKeys.find((key) => didYouMean(key, knownOps).length > 0);
+            if (typo || !jsonColumn) {
+                const badOp = typo ?? unknownKeys[0];
+                if (badOp) {
+                    throwUnsupportedWhereOperator(badOp, col, knownOps);
+                }
+            }
+        }
+        conditions.push(dialect.whereOperators.equals(sqlCol, nextParamIndex));
+        params.push(rawValue);
+        nextParamIndex++;
+        return { sql: conditions.join(" AND "), params, nextParamIndex };
+    }
+    if (unknownKeys[0]) {
+        throwUnsupportedWhereOperator(unknownKeys[0], col, knownOps);
+    }
+    for (const [op, value] of Object.entries(rawValue)) {
+        if (op === "mode")
+            continue;
+        if (op in spatialOps) {
+            const operator = spatialOps[op];
+            if (!operator) {
+                throwUnsupportedWhereOperator(op, col, knownOps);
+            }
+            const compiled = operator.compile(sqlCol, value, col, nextParamIndex, dialect);
+            conditions.push(compiled.sql);
+            params.push(...compiled.params);
+            nextParamIndex += compiled.params.length;
+            continue;
+        }
+        if (!(op in dialect.whereOperators)) {
+            throwUnsupportedWhereOperator(op, col, knownOps);
+        }
+        const operator = op;
+        if (PARAMLESS_OPERATORS.has(operator)) {
+            conditions.push(dialect.whereOperators[operator](sqlCol, nextParamIndex));
+            continue;
+        }
+        if (Array.isArray(value) && value.length === 0) {
+            if (operator === "in") {
+                conditions.push("1=0");
+                impossible = true;
+            }
+            else if (operator === "notIn") {
+                conditions.push("1=1");
+            }
+            continue;
+        }
+        const transform = operatorParamTransform[operator];
+        const paramValue = operator === "in" || operator === "notIn"
+            ? Array.isArray(value)
+                ? value.map((item) => serializeColumnValue(col, item, dialect))
+                : value
+            : transform
+                ? transform(value)
+                : serializeColumnValue(col, value, dialect);
+        conditions.push(isStringPatternOp(operator)
+            ? stringFilterSql(operator, sqlCol, nextParamIndex, queryMode, dialect)
+            : dialect.whereOperators[operator](sqlCol, nextParamIndex));
+        params.push(paramValue);
+        nextParamIndex++;
+    }
+    return compiledResult(conditions.join(" AND "), params, nextParamIndex, impossible);
+}
+function compileExistsSubquery(existsSql, negate) {
+    return negate ? `NOT EXISTS (${existsSql})` : `EXISTS (${existsSql})`;
+}
+function compileRelationCondition(manifest, parentTable, relation, rawValue, dialect, paramIndex, manifestIndex) {
+    const m2m = findM2M(manifest, parentTable.accessor, relation.name);
+    const targetTable = manifest.tables[relation.targetAccessor];
+    if (!targetTable) {
+        return { sql: "", params: [], nextParamIndex: paramIndex };
+    }
+    const parentTableIndex = getTableIndex(manifestIndex, parentTable.accessor);
+    if (relation.cardinality === "one") {
+        if (!isOperatorObject(rawValue) || Array.isArray(rawValue)) {
+            compileError(`Relation filter "${relation.name}" must be a where object`, {
+                tableAccessor: parentTable.accessor,
+                tableSqlName: parentTable.sqlName,
+            });
+        }
+        const relAlias = "_rel";
+        const columnRef = (col) => `${quoteIdentifier(relAlias)}.${quoteIdentifier(col.sqlName)}`;
+        const nested = compileWhereNode(manifest, targetTable, rawValue, dialect, paramIndex, columnRef, manifestIndex);
+        const parentFkCol = columnByTsName(parentTableIndex, parentTable, relation.fkColumn);
+        const parentFkRef = parentFkCol
+            ? `${tableRef(parentTable)}.${quoteIdentifier(parentFkCol.sqlName)}`
+            : `${tableRef(parentTable)}.${quoteIdentifier(relation.fkSqlColumn)}`;
+        const targetPkSql = targetRelationPkSql(targetTable, relation);
+        const joinCond = `${quoteIdentifier(relAlias)}.${quoteIdentifier(targetPkSql)} = ${parentFkRef}`;
+        const whereParts = [joinCond];
+        if (nested.sql)
+            whereParts.push(nested.sql);
+        const existsSql = `SELECT 1 FROM ${tableRef(targetTable)} AS ${quoteIdentifier(relAlias)} WHERE ${whereParts.join(" AND ")}`;
+        return compiledResult(compileExistsSubquery(existsSql, false), nested.params, nested.nextParamIndex, nested.impossible);
+    }
+    if (!isOperatorObject(rawValue) || Array.isArray(rawValue)) {
+        compileError(`Relation filter "${relation.name}" must be an object with some, every, or none`, {
+            tableAccessor: parentTable.accessor,
+            tableSqlName: parentTable.sqlName,
+        });
+    }
+    const relationModes = ["some", "every", "none"];
+    const modes = relationModes.filter((key) => key in rawValue);
+    if (modes.length !== 1) {
+        const hintKey = Object.keys(rawValue)[0] ?? "some";
+        compileError(`Relation filter "${relation.name}" requires exactly one of some, every, or none`, {
+            tableAccessor: parentTable.accessor,
+            tableSqlName: parentTable.sqlName,
+            suggestions: suggestWhereOperator(hintKey, relationModes),
+        });
+    }
+    const mode = modes[0];
+    if (!mode) {
+        compileError(`Relation filter "${relation.name}" requires exactly one of some, every, or none`, {
+            tableAccessor: parentTable.accessor,
+            tableSqlName: parentTable.sqlName,
+        });
+    }
+    const extraKeys = Object.keys(rawValue).filter((key) => key !== mode);
+    if (extraKeys[0]) {
+        compileError(`unsupported relation filter "${extraKeys[0]}" on "${relation.name}"`, {
+            tableAccessor: parentTable.accessor,
+            tableSqlName: parentTable.sqlName,
+            suggestions: suggestWhereOperator(extraKeys[0], relationModes),
+        });
+    }
+    const nestedWhere = rawValue[mode];
+    if (nestedWhere !== undefined && !isOperatorObject(nestedWhere)) {
+        compileError(`Relation filter "${relation.name}.${mode}" must be a where object`, {
+            tableAccessor: parentTable.accessor,
+            tableSqlName: parentTable.sqlName,
+        });
+    }
+    const relAlias = "_rel";
+    const columnRef = (col) => `${quoteIdentifier(relAlias)}.${quoteIdentifier(col.sqlName)}`;
+    const nested = compileWhereNode(manifest, targetTable, (nestedWhere ?? {}), dialect, paramIndex, columnRef, manifestIndex);
+    let fromClause;
+    const joinParts = [];
+    if (m2m) {
+        const isLeft = m2m.leftAccessor === parentTable.accessor;
+        const throughTable = manifest.tables[m2m.throughAccessor];
+        if (!throughTable) {
+            return { sql: "", params: [], nextParamIndex: paramIndex };
+        }
+        const junctionAlias = "_jt";
+        const parentFkCol = isLeft ? m2m.leftFkColumn : m2m.rightFkColumn;
+        const targetFkCol = isLeft ? m2m.rightFkColumn : m2m.leftFkColumn;
+        const targetPkSql = targetRelationPkSql(targetTable);
+        fromClause = `${tableRef(throughTable)} AS ${quoteIdentifier(junctionAlias)} INNER JOIN ${tableRef(targetTable)} AS ${quoteIdentifier(relAlias)} ON ${quoteIdentifier(relAlias)}.${quoteIdentifier(targetPkSql)} = ${quoteIdentifier(junctionAlias)}.${quoteIdentifier(targetFkCol)}`;
+        joinParts.push(`${quoteIdentifier(junctionAlias)}.${quoteIdentifier(parentFkCol)} = ${parentPkRef(parentTable)}`);
+    }
+    else {
+        fromClause = `${tableRef(targetTable)} AS ${quoteIdentifier(relAlias)}`;
+        joinParts.push(`${quoteIdentifier(relAlias)}.${quoteIdentifier(relation.fkSqlColumn)} = ${parentPkRef(parentTable)}`);
+    }
+    switch (mode) {
+        case "some":
+        case "none": {
+            const whereParts = nested.sql
+                ? [...joinParts, nested.sql]
+                : joinParts;
+            const existsSql = `SELECT 1 FROM ${fromClause} WHERE ${whereParts.join(" AND ")}`;
+            return compiledResult(compileExistsSubquery(existsSql, mode === "none"), nested.params, nested.nextParamIndex, mode === "some" && nested.impossible);
+        }
+        case "every": {
+            const everyWhereParts = nested.sql
+                ? [...joinParts, `NOT (${nested.sql})`]
+                : [...joinParts, "FALSE"];
+            const everySql = `SELECT 1 FROM ${fromClause} WHERE ${everyWhereParts.join(" AND ")}`;
+            return {
+                sql: compileExistsSubquery(everySql, true),
+                params: nested.params,
+                nextParamIndex: nested.nextParamIndex,
+            };
+        }
+        default: {
+            const _never = mode;
+            compileError(`unsupported relation filter "${String(_never)}" on "${relation.name}"`, {
+                tableAccessor: parentTable.accessor,
+                tableSqlName: parentTable.sqlName,
+            });
+        }
+    }
+}
+function combinatorTableContext(table) {
+    return {
+        tableAccessor: table.accessor,
+        tableSqlName: table.sqlName,
+    };
+}
+function compileLogicalCombinator(combinator, value, manifest, table, dialect, startParamIndex, columnRef, manifestIndex) {
+    if (!Array.isArray(value)) {
+        compileError(`${combinator} must be an array of where objects`, {
+            ...combinatorTableContext(table),
+        });
+    }
+    if (value.length === 0) {
+        return compiledResult(combinator === "OR" ? "1=0" : "1=1", [], startParamIndex, combinator === "OR");
+    }
+    const parts = [];
+    const params = [];
+    let paramIndex = startParamIndex;
+    const childImpossible = [];
+    for (const item of value) {
+        if (!isOperatorObject(item)) {
+            compileError(`${combinator} items must be where objects`, {
+                ...combinatorTableContext(table),
+            });
+        }
+        const compiled = compileWhereNode(manifest, table, item, dialect, paramIndex, columnRef, manifestIndex);
+        parts.push(`(${compiled.sql || "1=1"})`);
+        params.push(...compiled.params);
+        paramIndex = compiled.nextParamIndex;
+        childImpossible.push(Boolean(compiled.impossible));
+    }
+    const joiner = combinator === "OR" ? " OR " : " AND ";
+    const impossible = combinator === "OR"
+        ? childImpossible.every(Boolean)
+        : childImpossible.some(Boolean);
+    return compiledResult(`(${parts.join(joiner)})`, params, paramIndex, impossible);
+}
+function compileWhereNode(manifest, table, where, dialect, startParamIndex, columnRef = defaultColumnRef, manifestIndex) {
+    const conditions = [];
+    const params = [];
+    let paramIndex = startParamIndex;
+    let impossible = false;
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const relations = tableIndex?.effectiveRelationsByName ??
+        new Map(effectiveRelations(manifest, table).map((rel) => [rel.name, rel]));
+    for (const [key, value] of Object.entries(where)) {
+        if (value === undefined)
+            continue;
+        if (key === "AND" || key === "OR") {
+            const compiled = compileLogicalCombinator(key, value, manifest, table, dialect, paramIndex, columnRef, manifestIndex);
+            conditions.push(compiled.sql);
+            params.push(...compiled.params);
+            paramIndex = compiled.nextParamIndex;
+            if (compiled.impossible)
+                impossible = true;
+            continue;
+        }
+        if (key === "NOT") {
+            if (!isOperatorObject(value)) {
+                compileError("NOT must be a where object", {
+                    ...combinatorTableContext(table),
+                });
+            }
+            const compiled = compileWhereNode(manifest, table, value, dialect, paramIndex, columnRef, manifestIndex);
+            conditions.push(`NOT (${compiled.sql || "1=1"})`);
+            params.push(...compiled.params);
+            paramIndex = compiled.nextParamIndex;
+            continue;
+        }
+        const relation = relations.get(key);
+        if (relation) {
+            const compiled = compileRelationCondition(manifest, table, relation, value, dialect, paramIndex, manifestIndex);
+            if (compiled.sql)
+                conditions.push(compiled.sql);
+            params.push(...compiled.params);
+            paramIndex = compiled.nextParamIndex;
+            if (compiled.impossible)
+                impossible = true;
+            continue;
+        }
+        const col = requireTsColumn(tableIndex, table, key, "where", "select");
+        const compiled = compileColumnCondition(col, value, dialect, paramIndex, columnRef);
+        if (compiled.sql)
+            conditions.push(compiled.sql);
+        params.push(...compiled.params);
+        paramIndex = compiled.nextParamIndex;
+        if (compiled.impossible)
+            impossible = true;
+    }
+    return compiledResult(conditions.join(" AND "), params, paramIndex, impossible);
+}
+export function compileWhere(manifest, table, where, dialect, startParamIndex = 1, manifestIndex, qualifyColumns = false, tableAlias) {
+    if (!where || Object.keys(where).length === 0) {
+        return { sql: "", params: [] };
+    }
+    const columnRef = tableAlias
+        ? (col) => `${quoteIdentifier(tableAlias)}.${quoteIdentifier(col.sqlName)}`
+        : qualifyColumns
+            ? qualifiedColumnRefForTable(table)
+            : defaultColumnRef;
+    const result = compileWhereNode(manifest, table, where, dialect, startParamIndex, columnRef, manifestIndex);
+    return {
+        sql: result.sql ? `WHERE ${result.sql}` : "",
+        params: result.params,
+        ...(result.impossible ? { impossible: true } : {}),
+    };
+}
+function logicalShapeKey(combinator, value) {
+    if (value.length === 0)
+        return `${combinator}:empty`;
+    return `${combinator}:${value
+        .filter((item) => !!item && typeof item === "object" && !Array.isArray(item))
+        .map((item) => whereShapeKey(item) || "{}")
+        .join(",")}`;
+}
+export function whereShapeKey(where) {
+    const parts = [];
+    for (const [key, value] of Object.entries(where)) {
+        if (key === "AND" && Array.isArray(value)) {
+            parts.push(logicalShapeKey("AND", value));
+            continue;
+        }
+        if (key === "OR" && Array.isArray(value)) {
+            parts.push(logicalShapeKey("OR", value));
+            continue;
+        }
+        if (key === "NOT" && isOperatorObject(value)) {
+            parts.push(`NOT:${whereShapeKey(value)}`);
+            continue;
+        }
+        if (isOperatorObject(value) && !(value instanceof Date)) {
+            const ops = Object.keys(value).sort();
+            if (ops.some((op) => op === "some" || op === "every" || op === "none")) {
+                const mode = ops.find((op) => op === "some" || op === "every" || op === "none");
+                const nested = value[mode ?? ""];
+                parts.push(`${key}:rel:${mode}:${isOperatorObject(nested) ? whereShapeKey(nested) : "{}"}`);
+            }
+            else if (ops.includes("in") || ops.includes("notIn")) {
+                const arr = value.in ?? value.notIn;
+                const len = Array.isArray(arr) ? arr.length : 0;
+                const op = ops.includes("in") ? "in" : "notIn";
+                parts.push(`${key}:${op}:${len}`);
+            }
+            else {
+                const modePart = typeof value.mode === "string" ? `:mode:${value.mode}` : "";
+                const opsForKey = ops.filter((op) => op !== "mode");
+                parts.push(`${key}:${opsForKey.join(",")}${modePart}`);
+            }
+            continue;
+        }
+        parts.push(`${key}:eq`);
+    }
+    return parts.join("&");
+}
+function collectWhereParams(manifest, table, where, dialect, manifestIndex) {
+    const params = [];
+    function walk(node, columnRef) {
+        const tableIndex = getTableIndex(manifestIndex, table.accessor);
+        const relations = tableIndex?.effectiveRelationsByName ??
+            new Map(effectiveRelations(manifest, table).map((rel) => [
+                rel.name,
+                rel,
+            ]));
+        for (const [key, value] of Object.entries(node)) {
+            if (key === "AND" || key === "OR") {
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        if (item &&
+                            typeof item === "object" &&
+                            !Array.isArray(item)) {
+                            walk(item, columnRef);
+                        }
+                    }
+                }
+                continue;
+            }
+            if (key === "NOT" && isOperatorObject(value)) {
+                walk(value, columnRef);
+                continue;
+            }
+            if (relations.get(key)) {
+                const compiled = compileRelationCondition(manifest, table, relations.get(key), value, dialect, 1, manifestIndex);
+                params.push(...compiled.params);
+                continue;
+            }
+            const col = columnByTsName(tableIndex, table, key);
+            if (!col)
+                continue;
+            const compiled = compileColumnCondition(col, value, dialect, 1, columnRef);
+            params.push(...compiled.params);
+        }
+    }
+    walk(where, defaultColumnRef);
+    return params;
+}
+function whereValuesFingerprint(manifest, table, where, dialect, manifestIndex) {
+    return JSON.stringify(collectWhereParams(manifest, table, where, dialect, manifestIndex));
+}
+export function getCachedWhereClause(manifest, table, where, dialect, startParamIndex = 1, manifestIndex, qualifyColumns = false) {
+    if (!where || Object.keys(where).length === 0) {
+        return { sql: "", params: [] };
+    }
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const shape = qualifyColumns
+        ? `${whereShapeKey(where)}|qualified`
+        : whereShapeKey(where);
+    const shellCached = tableIndex?.whereClauseByShape.get(shape);
+    if (shellCached) {
+        return {
+            sql: shellCached.sql,
+            params: collectWhereParams(manifest, table, where, dialect, manifestIndex),
+            ...(shellCached.impossible ? { impossible: true } : {}),
+        };
+    }
+    const fingerprint = whereValuesFingerprint(manifest, table, where, dialect, manifestIndex);
+    const cacheKey = `${shape}\0${fingerprint}`;
+    const cached = tableIndex?.whereClauseByFingerprint.get(cacheKey);
+    if (cached)
+        return cached;
+    const compiled = compileWhere(manifest, table, where, dialect, startParamIndex, manifestIndex, qualifyColumns);
+    tableIndex?.whereClauseByShape.set(shape, {
+        sql: compiled.sql,
+        ...(compiled.impossible ? { impossible: true } : {}),
+    });
+    tableIndex?.whereClauseByFingerprint.set(cacheKey, compiled);
+    return compiled;
+}
+export function orderByShapeKey(orderBy, tableAlias) {
+    if (!orderBy || Object.keys(orderBy).length === 0)
+        return "";
+    const entries = Object.entries(orderBy)
+        .filter(([key]) => key !== "_count")
+        .map(([key, direction]) => typeof direction === "string"
+        ? `${key}:${direction.toUpperCase()}`
+        : "")
+        .filter(Boolean);
+    if (entries.length === 0)
+        return "";
+    const base = entries.join("|");
+    return tableAlias ? `${base}|@${tableAlias}` : base;
+}
+export function getCachedOrderByClause(table, orderBy, tableAlias, manifestIndex) {
+    if (!orderBy || Object.keys(orderBy).length === 0)
+        return "";
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const shape = orderByShapeKey(orderBy, tableAlias);
+    if (!shape)
+        return "";
+    if (!tableIndex) {
+        return compileOrderBy(table, orderBy, tableAlias, manifestIndex);
+    }
+    return getOrSetSqlCache(tableIndex.orderBySqlByShape, shape, () => compileOrderBy(table, orderBy, tableAlias, manifestIndex));
+}
+export function isImpossibleWhereSql(sql) {
+    if (!sql)
+        return false;
+    return /^1\s*=\s*0$/.test(sql.trim());
+}
+export function isImpossibleWhere(whereSql) {
+    if (!whereSql)
+        return false;
+    return isImpossibleWhereSql(whereSql.replace(/^WHERE\s+/i, ""));
+}
+export function compileOrderBy(table, orderBy, tableAlias, manifestIndex) {
+    if (!orderBy || Object.keys(orderBy).length === 0)
+        return "";
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const prefix = tableAlias ? `${quoteIdentifier(tableAlias)}.` : "";
+    const parts = [];
+    for (const [tsKey, direction] of Object.entries(orderBy)) {
+        if (tsKey === "_count" || typeof direction !== "string")
+            continue;
+        const col = columnByTsName(tableIndex, table, tsKey);
+        if (!col)
+            continue;
+        const dir = direction.toUpperCase() === "DESC" ? "DESC" : "ASC";
+        parts.push(`${prefix}${quoteIdentifier(col.sqlName)} ${dir}`);
+    }
+    return parts.length > 0 ? `ORDER BY ${parts.join(", ")}` : "";
+}
+export function normalizeSelectColumns(select) {
+    if (!select)
+        return undefined;
+    if (Array.isArray(select))
+        return select;
+    return Object.entries(select)
+        .filter(([, enabled]) => enabled === true)
+        .map(([key]) => key);
+}
+/** Columns returned by default SELECT (omits `.hidden()` unless `includeHidden` or explicitly selected). */
+export function columnsForOutput(tableIndex, table, select, includeHidden) {
+    if (select && select.length > 0) {
+        return columnsByTsNames(tableIndex, table, select);
+    }
+    if (includeHidden) {
+        return table.columns;
+    }
+    return table.columns.filter((col) => col.hidden !== true);
+}
+function aliasToTsName(expression, col) {
+    if (col.sqlName === col.tsName)
+        return expression;
+    return `${expression} AS ${quoteIdentifier(col.tsName)}`;
+}
+function selectExpression(col) {
+    if (col.kind === "fk") {
+        return aliasToTsName(quoteIdentifier(col.sqlName), col);
+    }
+    const plugin = getColumnType(col.kind);
+    if (plugin?.selectExpression) {
+        return aliasToTsName(plugin.selectExpression(col), col);
+    }
+    return aliasToTsName(quoteIdentifier(col.sqlName), col);
+}
+export function buildSelectColumns(table, select, manifestIndex, includeHidden, tableAlias) {
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const cols = columnsForOutput(tableIndex, table, select, includeHidden);
+    const prefix = tableAlias ? `${quoteIdentifier(tableAlias)}.` : "";
+    return cols.map((c) => `${prefix}${selectExpression(c)}`).join(", ");
+}
+export function buildQualifiedSelectColumns(table, select, manifestIndex, includeHidden) {
+    const ref = tableRef(table);
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const cols = columnsForOutput(tableIndex, table, select, includeHidden);
+    return cols.map((c) => `${ref}.${selectExpression(c)}`).join(", ");
+}
+export function buildFindByIdQuery(table, select, manifestIndex, includeHidden) {
+    const { sqlName } = requireScalarPrimaryKey(table);
+    const sqlCol = quoteIdentifier(sqlName);
+    const selectCols = buildSelectColumns(table, select, manifestIndex, includeHidden);
+    return `SELECT ${selectCols} FROM ${tableRef(table)} WHERE ${sqlCol} = $1`;
+}
+export function buildFindAllQuery(table) {
+    return `SELECT ${buildSelectColumns(table)} FROM ${tableRef(table)}`;
+}
+export function normalizeLimitOffset(value, label) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+        compileError(`${label} must be a non-negative integer, got ${JSON.stringify(value)}`);
+    }
+    return value;
+}
+export function buildFindManyQuery(table, whereSql, orderSql, take, skip, distinctOn, extraSelectCols, joinClauses, manifestIndex, groupBySql, select, includeHidden) {
+    const hasJoins = Boolean(joinClauses && joinClauses.length > 0);
+    const tableIndex = getTableIndex(manifestIndex, table.accessor);
+    const selectCols = hasJoins
+        ? buildQualifiedSelectColumns(table, select, manifestIndex, includeHidden)
+        : buildSelectColumns(table, select, manifestIndex, includeHidden);
+    let sql = "SELECT ";
+    if (distinctOn && distinctOn.length > 0) {
+        const distinctCols = columnsByTsNames(tableIndex, table, distinctOn)
+            .map((col) => hasJoins
+            ? `${tableRef(table)}.${quoteIdentifier(col.sqlName)}`
+            : quoteIdentifier(col.sqlName))
+            .join(", ");
+        sql += `DISTINCT ON (${distinctCols}) `;
+    }
+    sql += selectCols;
+    if (extraSelectCols && extraSelectCols.length > 0) {
+        sql += `, ${extraSelectCols.join(", ")}`;
+    }
+    sql += ` FROM ${tableRef(table)}`;
+    if (joinClauses && joinClauses.length > 0) {
+        sql += ` ${joinClauses.join(" ")}`;
+    }
+    if (whereSql)
+        sql += ` ${whereSql}`;
+    if (groupBySql)
+        sql += ` ${groupBySql}`;
+    if (orderSql)
+        sql += ` ${orderSql}`;
+    if (take !== undefined) {
+        sql += ` LIMIT ${normalizeLimitOffset(take, "take")}`;
+    }
+    if (skip !== undefined) {
+        sql += ` OFFSET ${normalizeLimitOffset(skip, "skip")}`;
+    }
+    return sql;
+}
+export function buildPaginateQuery(table, whereSql, orderSql, take, extraSelectCols, joinClauses, manifestIndex, select, includeHidden) {
+    return buildFindManyQuery(table, whereSql, orderSql, take + 1, undefined, undefined, extraSelectCols, joinClauses, manifestIndex, undefined, select, includeHidden);
+}
+export function buildExistsQuery(table, whereSql) {
+    let sql = `SELECT 1 FROM ${tableRef(table)}`;
+    if (whereSql)
+        sql += ` ${whereSql}`;
+    sql += " LIMIT 1";
+    return sql;
+}
+export function getCachedFindManyQuery(tableIndex, signature, build) {
+    if (!tableIndex)
+        return build();
+    return getOrSetSqlCache(tableIndex.findManySqlBySignature, signature, build);
+}
+//# sourceMappingURL=compile-where.js.map