prisma-sql 1.63.0 → 1.65.0

package/dist/index.js

@@ -650,81 +650,6 @@ function needsQuoting(identifier) {
   return false;
 }
 
-// src/builder/shared/model-field-cache.ts
-var MODEL_CACHE = /* @__PURE__ */ new WeakMap();
-function quoteIdent(id) {
-  if (typeof id !== "string" || id.trim().length === 0) {
-    throw new Error("quoteIdent: identifier is required and cannot be empty");
-  }
-  for (let i = 0; i < id.length; i++) {
-    const code = id.charCodeAt(i);
-    if (code >= 0 && code <= 31 || code === 127) {
-      throw new Error(
-        `quoteIdent: identifier contains invalid characters: ${JSON.stringify(id)}`
-      );
-    }
-  }
-  if (needsQuoting(id)) {
-    return `"${id.replace(/"/g, '""')}"`;
-  }
-  return id;
-}
-function ensureFullCache(model) {
-  let cache = MODEL_CACHE.get(model);
-  if (!cache) {
-    const fieldInfo = /* @__PURE__ */ new Map();
-    const scalarFields = /* @__PURE__ */ new Set();
-    const relationFields = /* @__PURE__ */ new Set();
-    const columnMap = /* @__PURE__ */ new Map();
-    const fieldByName = /* @__PURE__ */ new Map();
-    const quotedColumns = /* @__PURE__ */ new Map();
-    for (const f of model.fields) {
-      const info = {
-        name: f.name,
-        dbName: f.dbName || f.name,
-        type: f.type,
-        isRelation: !!f.isRelation,
-        isRequired: !!f.isRequired
-      };
-      fieldInfo.set(f.name, info);
-      fieldByName.set(f.name, f);
-      if (info.isRelation) {
-        relationFields.add(f.name);
-      } else {
-        scalarFields.add(f.name);
-        const dbName = info.dbName;
-        columnMap.set(f.name, dbName);
-        quotedColumns.set(f.name, quoteIdent(dbName));
-      }
-    }
-    cache = {
-      fieldInfo,
-      scalarFields,
-      relationFields,
-      columnMap,
-      fieldByName,
-      quotedColumns
-    };
-    MODEL_CACHE.set(model, cache);
-  }
-  return cache;
-}
-function getFieldInfo(model, fieldName) {
-  return ensureFullCache(model).fieldInfo.get(fieldName);
-}
-function getScalarFieldSet(model) {
-  return ensureFullCache(model).scalarFields;
-}
-function getRelationFieldSet(model) {
-  return ensureFullCache(model).relationFields;
-}
-function getColumnMap(model) {
-  return ensureFullCache(model).columnMap;
-}
-function getQuotedColumn(model, fieldName) {
-  return ensureFullCache(model).quotedColumns.get(fieldName);
-}
-
 // src/builder/shared/sql-utils.ts
 function containsControlChars(s) {
   for (let i = 0; i < s.length; i++) {
@@ -1026,6 +951,70 @@ function normalizeKeyList(input) {
   return s.length > 0 ? [s] : [];
 }
 
+// src/builder/shared/model-field-cache.ts
+var SCALAR_FIELD_CACHE = /* @__PURE__ */ new WeakMap();
+var RELATION_FIELD_CACHE = /* @__PURE__ */ new WeakMap();
+var COLUMN_MAP_CACHE = /* @__PURE__ */ new WeakMap();
+var QUOTED_COLUMN_CACHE = /* @__PURE__ */ new WeakMap();
+var FIELD_BY_NAME_CACHE = /* @__PURE__ */ new WeakMap();
+function getScalarFieldSet(model) {
+  let cached = SCALAR_FIELD_CACHE.get(model);
+  if (cached) return cached;
+  const set = /* @__PURE__ */ new Set();
+  for (const f of model.fields) {
+    if (!f.isRelation) set.add(f.name);
+  }
+  SCALAR_FIELD_CACHE.set(model, set);
+  return set;
+}
+function getRelationFieldSet(model) {
+  let cached = RELATION_FIELD_CACHE.get(model);
+  if (cached) return cached;
+  const set = /* @__PURE__ */ new Set();
+  for (const f of model.fields) {
+    if (f.isRelation) set.add(f.name);
+  }
+  RELATION_FIELD_CACHE.set(model, set);
+  return set;
+}
+function getColumnMap(model) {
+  let cached = COLUMN_MAP_CACHE.get(model);
+  if (cached) return cached;
+  const map = /* @__PURE__ */ new Map();
+  for (const f of model.fields) {
+    if (f.dbName && f.dbName !== f.name) {
+      map.set(f.name, f.dbName);
+    }
+  }
+  COLUMN_MAP_CACHE.set(model, map);
+  return map;
+}
+function getQuotedColumn(model, fieldName) {
+  let cache = QUOTED_COLUMN_CACHE.get(model);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    QUOTED_COLUMN_CACHE.set(model, cache);
+  }
+  const cached = cache.get(fieldName);
+  if (cached !== void 0) return cached;
+  const columnMap = getColumnMap(model);
+  const columnName = columnMap.get(fieldName) || fieldName;
+  const quoted = quote(columnName);
+  cache.set(fieldName, quoted);
+  return quoted;
+}
+function getFieldByName(model, fieldName) {
+  let cache = FIELD_BY_NAME_CACHE.get(model);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    for (const field of model.fields) {
+      cache.set(field.name, field);
+    }
+    FIELD_BY_NAME_CACHE.set(model, cache);
+  }
+  return cache.get(fieldName);
+}
+
 // src/builder/joins.ts
 function isRelationField(fieldName, model) {
   return getRelationFieldSet(model).has(fieldName);
@@ -1139,11 +1128,18 @@ var getNextSort = (sortRaw) => {
   return sortRaw;
 };
 var flipObjectSort = (obj) => {
-  const sortRaw = obj.sort;
-  const out = __spreadProps(__spreadValues({}, obj), { sort: getNextSort(sortRaw) });
-  const nullsRaw = obj.nulls;
-  if (typeof nullsRaw === "string") {
-    out.nulls = flipNulls(nullsRaw);
+  const out = __spreadValues({}, obj);
+  const hasSort = Object.prototype.hasOwnProperty.call(obj, "sort");
+  const hasDirection = Object.prototype.hasOwnProperty.call(obj, "direction");
+  if (hasSort) {
+    out.sort = getNextSort(obj.sort);
+  } else if (hasDirection) {
+    out.direction = getNextSort(obj.direction);
+  } else {
+    out.sort = getNextSort(obj.sort);
+  }
+  if (typeof obj.nulls === "string") {
+    out.nulls = flipNulls(obj.nulls);
   }
   return out;
 };
@@ -1189,7 +1185,7 @@ var normalizePairs = (pairs, parseValue) => {
   return pairs.map(([field, rawValue]) => {
     const parsed = parseValue(rawValue, field);
     return {
-      [field]: parsed.nulls !== void 0 ? { sort: parsed.direction, nulls: parsed.nulls } : parsed.direction
+      [field]: parsed.nulls !== void 0 ? { direction: parsed.direction, nulls: parsed.nulls } : parsed.direction
     };
   });
 };
@@ -1238,37 +1234,113 @@ function ensureDeterministicOrderByInput(args) {
 }
 
 // src/builder/shared/validators/field-assertions.ts
-var NUMERIC_TYPES = /* @__PURE__ */ new Set(["Int", "Float", "Decimal", "BigInt"]);
-function assertScalarField(model, fieldName, context) {
-  const field = getFieldInfo(model, fieldName);
+function assertFieldExists(fieldName, model, path) {
+  const field = getFieldByName(model, fieldName);
   if (!field) {
     throw createError(
-      `${context} references unknown field '${fieldName}' on model ${model.name}`,
+      `Field '${fieldName}' does not exist on model ${model.name}`,
       {
         field: fieldName,
         modelName: model.name,
-        availableFields: model.fields.map((f) => f.name)
+        path
       }
     );
   }
+  return field;
+}
+function assertScalarField(model, fieldName, context) {
+  const field = getFieldByName(model, fieldName);
+  if (!field) {
+    throw new Error(
+      `${context}: field '${fieldName}' does not exist on model '${model.name}'`
+    );
+  }
   if (field.isRelation) {
-    throw createError(
-      `${context} does not support relation field '${fieldName}'`,
-      { field: fieldName, modelName: model.name }
+    throw new Error(
+      `${context}: field '${fieldName}' is a relation field, expected scalar field`
     );
   }
-  return field;
 }
 function assertNumericField(model, fieldName, context) {
-  const field = assertScalarField(model, fieldName, context);
-  const baseType = field.type.replace(/\[\]|\?/g, "");
-  if (!NUMERIC_TYPES.has(baseType)) {
+  assertScalarField(model, fieldName, context);
+  const field = getFieldByName(model, fieldName);
+  if (!field) return;
+  const numericTypes = /* @__PURE__ */ new Set([
+    "Int",
+    "BigInt",
+    "Float",
+    "Decimal",
+    "Int?",
+    "BigInt?",
+    "Float?",
+    "Decimal?"
+  ]);
+  if (!numericTypes.has(field.type)) {
+    throw new Error(
+      `${context}: field '${fieldName}' must be numeric (Int, BigInt, Float, Decimal), got '${field.type}'`
+    );
+  }
+}
+function assertValidOperator(fieldName, operator, fieldType, path, modelName) {
+  const stringOps = /* @__PURE__ */ new Set([
+    "equals",
+    "not",
+    "in",
+    "notIn",
+    "lt",
+    "lte",
+    "gt",
+    "gte",
+    "contains",
+    "startsWith",
+    "endsWith",
+    "mode",
+    "search"
+  ]);
+  const numericOps = /* @__PURE__ */ new Set([
+    "equals",
+    "not",
+    "in",
+    "notIn",
+    "lt",
+    "lte",
+    "gt",
+    "gte"
+  ]);
+  const jsonOps = /* @__PURE__ */ new Set([
+    "equals",
+    "not",
+    "path",
+    "string_contains",
+    "string_starts_with",
+    "string_ends_with",
+    "array_contains",
+    "array_starts_with",
+    "array_ends_with"
+  ]);
+  const isString = fieldType === "String" || fieldType === "String?";
+  const isNumeric = ["Int", "BigInt", "Float", "Decimal"].some(
+    (t) => fieldType === t || fieldType === `${t}?`
+  );
+  const isJson = fieldType === "Json" || fieldType === "Json?";
+  if (isString && !stringOps.has(operator)) {
     throw createError(
-      `${context} requires numeric field, got '${field.type}'`,
-      { field: fieldName, modelName: model.name }
+      `Operator '${operator}' is not valid for String field '${fieldName}'`,
+      { field: fieldName, modelName, path, operator }
+    );
+  }
+  if (isNumeric && !numericOps.has(operator)) {
+    throw createError(
+      `Operator '${operator}' is not valid for numeric field '${fieldName}'`,
+      { field: fieldName, modelName, path, operator }
+    );
+  }
+  if (isJson && !jsonOps.has(operator)) {
+    throw createError(
+      `Operator '${operator}' is not valid for Json field '${fieldName}'`,
+      { field: fieldName, modelName, path, operator }
     );
   }
-  return field;
 }
 
 // src/builder/pagination.ts
@@ -1782,6 +1854,14 @@ function handleInOperator(expr, op, val, params, dialect) {
   if (val.length === 0) {
     return op === Ops.IN ? "0=1" : "1=1";
   }
+  if (dialect === "sqlite" && val.length <= 30) {
+    const placeholders = [];
+    for (const item of val) {
+      placeholders.push(params.add(item));
+    }
+    const list = placeholders.join(", ");
+    return op === Ops.IN ? `${expr} IN (${list})` : `${expr} NOT IN (${list})`;
+  }
   const paramValue = prepareArrayParam(val, dialect);
   const placeholder = params.add(paramValue);
   return op === Ops.IN ? inArray(expr, placeholder, dialect) : notInArray(expr, placeholder, dialect);
@@ -2317,57 +2397,6 @@ function buildNestedRelation(fieldName, value, ctx, whereBuilder) {
   return buildTopLevelRelation(fieldName, value, ctx, whereBuilder);
 }
 
-// src/builder/shared/validators/field-validators.ts
-function assertFieldExists(name, model, path) {
-  const field = model.fields.find((f) => f.name === name);
-  if (!isNotNullish(field)) {
-    throw createError(`Field '${name}' does not exist on '${model.name}'`, {
-      field: name,
-      path,
-      modelName: model.name,
-      availableFields: model.fields.map((f) => f.name)
-    });
-  }
-  return field;
-}
-function assertValidOperator(fieldName, op, fieldType, path, modelName) {
-  if (!isNotNullish(fieldType)) return;
-  const ARRAY_OPS = /* @__PURE__ */ new Set([
-    Ops.HAS,
-    Ops.HAS_SOME,
-    Ops.HAS_EVERY,
-    Ops.IS_EMPTY
-  ]);
-  const JSON_OPS2 = /* @__PURE__ */ new Set([
-    Ops.PATH,
-    Ops.STRING_CONTAINS,
-    Ops.STRING_STARTS_WITH,
-    Ops.STRING_ENDS_WITH
-  ]);
-  const isArrayOp = ARRAY_OPS.has(op);
-  const isFieldArray = isArrayType(fieldType);
-  const arrayOpMismatch = isArrayOp && !isFieldArray;
-  if (arrayOpMismatch) {
-    throw createError(`'${op}' requires array field, got '${fieldType}'`, {
-      operator: op,
-      field: fieldName,
-      path,
-      modelName
-    });
-  }
-  const isJsonOp = JSON_OPS2.has(op);
-  const isFieldJson = isJsonType(fieldType);
-  const jsonOpMismatch = isJsonOp && !isFieldJson;
-  if (jsonOpMismatch) {
-    throw createError(`'${op}' requires JSON field, got '${fieldType}'`, {
-      operator: op,
-      field: fieldName,
-      path,
-      modelName
-    });
-  }
-}
-
 // src/builder/where/builder.ts
 var MAX_QUERY_DEPTH = 50;
 var EMPTY_JOINS = Object.freeze([]);
@@ -2424,6 +2453,23 @@ function buildRelationFilter(fieldName, value, ctx, builder) {
   }
   return buildTopLevelRelation(fieldName, value, ctx2, builder);
 }
+function buildSimpleEquality(expr, value, ctx) {
+  if (value === null) return `${expr} ${SQL_TEMPLATES.IS_NULL}`;
+  const placeholder = ctx.params.addAuto(value);
+  return `${expr} = ${placeholder}`;
+}
+function isSimpleWhere(where) {
+  const keys = Object.keys(where);
+  if (keys.length !== 1) return false;
+  const key = keys[0];
+  const value = where[key];
+  if (value === null) return true;
+  if (value === void 0) return false;
+  if (typeof value === "string") return true;
+  if (typeof value === "number") return true;
+  if (typeof value === "boolean") return true;
+  return false;
+}
 function buildWhereEntry(key, value, ctx, builder) {
   const op = asLogicalOperator(key);
   if (op) return buildLogical(op, value, ctx, builder);
@@ -2450,6 +2496,14 @@ function buildWhereInternal(where, ctx, builder) {
   if (isEmptyWhere(where)) {
     return freezeResult(DEFAULT_WHERE_CLAUSE, EMPTY_JOINS);
   }
+  if (isSimpleWhere(where)) {
+    const key = Object.keys(where)[0];
+    const value = where[key];
+    assertFieldExists(key, ctx.model, ctx.path);
+    const expr = col(ctx.alias, key, ctx.model);
+    const clause = buildSimpleEquality(expr, value, ctx);
+    return freezeResult(clause, EMPTY_JOINS);
+  }
   const allJoins = [];
   const clauses = [];
   for (const key in where) {
@@ -2576,10 +2630,16 @@ function buildOperator(expr, op, val, ctx, mode, fieldType) {
 }
 
 // src/builder/shared/alias-generator.ts
+var SAFE_IDENTIFIER_CACHE = /* @__PURE__ */ new Map();
 function toSafeSqlIdentifier(input) {
+  const cached = SAFE_IDENTIFIER_CACHE.get(input);
+  if (cached !== void 0) return cached;
   const raw = String(input);
   const n = raw.length;
-  if (n === 0) return "_t";
+  if (n === 0) {
+    SAFE_IDENTIFIER_CACHE.set(input, "_t");
+    return "_t";
+  }
   let out = "";
   for (let i = 0; i < n; i++) {
     const c = raw.charCodeAt(i);
@@ -2591,7 +2651,11 @@ function toSafeSqlIdentifier(input) {
   const c0 = out.charCodeAt(0);
   const startsOk = c0 >= 65 && c0 <= 90 || c0 >= 97 && c0 <= 122 || c0 === 95;
   const lowered = (startsOk ? out : `_${out}`).toLowerCase();
-  return ALIAS_FORBIDDEN_KEYWORDS.has(lowered) ? `_${lowered}` : lowered;
+  const result = ALIAS_FORBIDDEN_KEYWORDS.has(lowered) ? `_${lowered}` : lowered;
+  if (SAFE_IDENTIFIER_CACHE.size < 1e3) {
+    SAFE_IDENTIFIER_CACHE.set(input, result);
+  }
+  return result;
 }
 function createAliasGenerator(maxAliases = 1e4) {
   let counter = 0;
@@ -2702,9 +2766,17 @@ function assertCanAddParam(currentIndex) {
     );
   }
 }
-function formatPosition(position) {
+var POSTGRES_POSITION_CACHE = new Array(100);
+for (let i = 0; i < 100; i++) {
+  POSTGRES_POSITION_CACHE[i] = `$${i + 1}`;
+}
+function formatPositionPostgres(position) {
+  if (position <= 100) return POSTGRES_POSITION_CACHE[position - 1];
   return `$${position}`;
 }
+function formatPositionSqlite(_position) {
+  return "?";
+}
 function validateDynamicName(dynamicName) {
   const dn = dynamicName.trim();
   if (dn.length === 0) {
@@ -2712,13 +2784,14 @@ function validateDynamicName(dynamicName) {
   }
   return dn;
 }
-function createStoreInternal(startIndex, initialParams = [], initialMappings = []) {
+function createStoreInternal(startIndex, dialect, initialParams = [], initialMappings = []) {
   let index = startIndex;
   const params = initialParams.length > 0 ? initialParams.slice() : [];
   const mappings = initialMappings.length > 0 ? initialMappings.slice() : [];
   const dynamicNameToIndex = buildDynamicNameIndex(mappings);
   let dirty = true;
   let cachedSnapshot = null;
+  const formatPosition = dialect === "sqlite" ? formatPositionSqlite : formatPositionPostgres;
   function addDynamic(dynamicName) {
     const dn = validateDynamicName(dynamicName);
     const existing = dynamicNameToIndex.get(dn);
@@ -2768,10 +2841,13 @@ function createStoreInternal(startIndex, initialParams = [], initialMappings = [
     snapshot,
     get index() {
       return index;
+    },
+    get dialect() {
+      return dialect;
     }
   };
 }
-function createParamStore(startIndex = 1) {
+function createParamStore(startIndex = 1, dialect = "postgres") {
   if (!Number.isInteger(startIndex) || startIndex < 1) {
     throw new Error(`Start index must be integer >= 1, got ${startIndex}`);
   }
@@ -2780,12 +2856,13 @@ function createParamStore(startIndex = 1) {
       `Start index too high (${startIndex}), risk of overflow at MAX_SAFE_INTEGER`
     );
   }
-  return createStoreInternal(startIndex);
+  return createStoreInternal(startIndex, dialect);
 }
-function createParamStoreFrom(existingParams, existingMappings, nextIndex) {
+function createParamStoreFrom(existingParams, existingMappings, nextIndex, dialect = "postgres") {
   validateState(existingParams, existingMappings, nextIndex);
   return createStoreInternal(
     nextIndex,
+    dialect,
     existingParams.slice(),
     existingMappings.slice()
   );
@@ -2826,6 +2903,7 @@ function buildWhereClause(where, options) {
 }
 
 // src/builder/select/fields.ts
+var DEFAULT_SELECT_CACHE = /* @__PURE__ */ new WeakMap();
 function toSelectEntries(select) {
   const out = [];
   for (const [k, v] of Object.entries(select)) {
@@ -2873,13 +2951,29 @@ function buildDefaultScalarFields(model, alias) {
   }
   return out;
 }
+function getDefaultSelectCached(model, alias) {
+  var _a;
+  return (_a = DEFAULT_SELECT_CACHE.get(model)) == null ? void 0 : _a.get(alias);
+}
+function cacheDefaultSelect(model, alias, sql) {
+  let cache = DEFAULT_SELECT_CACHE.get(model);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    DEFAULT_SELECT_CACHE.set(model, cache);
+  }
+  cache.set(alias, sql);
+}
 function buildSelectFields(args, model, alias) {
   const scalarSet = getScalarFieldSet(model);
   const relationSet = getRelationFieldSet(model);
   if (!isNotNullish(args.select)) {
-    return buildDefaultScalarFields(model, alias).join(
+    const cached = getDefaultSelectCached(model, alias);
+    if (cached) return cached;
+    const result = buildDefaultScalarFields(model, alias).join(
       SQL_SEPARATORS.FIELD_LIST
     );
+    cacheDefaultSelect(model, alias, result);
+    return result;
   }
   const entries = toSelectEntries(args.select);
   validateSelectKeys(entries, scalarSet, relationSet);
@@ -2957,8 +3051,6 @@ function buildRelationSelect(relArgs, relModel, relAlias) {
   }
   return buildAllScalarParts(relModel, relAlias).join(SQL_SEPARATORS.FIELD_LIST);
 }
-
-// src/builder/select/includes.ts
 var MAX_INCLUDE_DEPTH = 10;
 var MAX_TOTAL_SUBQUERIES = 100;
 var MAX_TOTAL_INCLUDES = 50;
@@ -3146,8 +3238,12 @@ function buildWhereParts(whereInput, relModel, relAlias, ctx) {
     dialect: ctx.dialect
   });
   const joins = whereResult.joins.join(" ");
-  const whereClause = isValidWhereClause(whereResult.clause) ? ` ${SQL_TEMPLATES.AND} ${whereResult.clause}` : "";
-  return { joins, whereClause };
+  const hasClause = isValidWhereClause(whereResult.clause);
+  return {
+    joins,
+    whereClause: hasClause ? ` ${SQL_TEMPLATES.AND} ${whereResult.clause}` : "",
+    rawClause: hasClause ? whereResult.clause : ""
+  };
 }
 function limitOneSql(sql, params, skipVal, scope) {
   if (isNotNullish(skipVal)) {
@@ -3192,8 +3288,10 @@ function buildListIncludeSpec(args) {
   const rowExpr = jsonBuildObject(args.relSelect, args.ctx.dialect);
   const noTake = !isNotNullish(args.takeVal);
   const noSkip = !isNotNullish(args.skipVal);
+  const emptyJson = args.ctx.dialect === "postgres" ? `'[]'::json` : `json('[]')`;
   if (args.ctx.dialect === "postgres" && noTake && noSkip) {
-    const selectExpr2 = args.orderBySql ? `json_agg(${rowExpr} ORDER BY ${args.orderBySql})` : `json_agg(${rowExpr})`;
+    const rawAgg = args.orderBySql ? `json_agg(${rowExpr} ORDER BY ${args.orderBySql})` : `json_agg(${rowExpr})`;
+    const selectExpr2 = `COALESCE(${rawAgg}, ${emptyJson})`;
     const sql2 = buildBaseSql({
       selectExpr: selectExpr2,
       relTable: args.relTable,
@@ -3223,10 +3321,154 @@ function buildListIncludeSpec(args) {
     args.skipVal,
     scopeBase
   );
-  const selectExpr = jsonAgg("row", args.ctx.dialect);
+  const agg = jsonAgg("row", args.ctx.dialect);
+  const selectExpr = `COALESCE(${agg}, ${emptyJson})`;
   const sql = `${SQL_TEMPLATES.SELECT} ${selectExpr} ${SQL_TEMPLATES.FROM} (${base}) ${SQL_TEMPLATES.AS} ${rowAlias}`;
   return Object.freeze({ name: args.relName, sql, isOneToOne: false });
 }
+function resolveIncludeKeyPairs(field) {
+  const fkFields = normalizeKeyList(field.foreignKey);
+  if (fkFields.length === 0) {
+    throw new Error(
+      `Relation '${field.name}' is missing foreignKey for join-based include`
+    );
+  }
+  const refs = normalizeKeyList(field.references);
+  const refFields = refs.length > 0 ? refs : fkFields.length === 1 ? ["id"] : [];
+  if (refFields.length !== fkFields.length) {
+    throw new Error(
+      `Relation '${field.name}' references count doesn't match foreignKey count`
+    );
+  }
+  return {
+    relKeyFields: field.isForeignKeyLocal ? refFields : fkFields,
+    parentKeyFields: field.isForeignKeyLocal ? fkFields : refFields
+  };
+}
+function buildFkSelectList(relAlias, relModel, relKeyFields) {
+  return relKeyFields.map((f, i) => `${relAlias}.${quoteColumn(relModel, f)} AS "__fk${i}"`).join(SQL_SEPARATORS.FIELD_LIST);
+}
+function buildFkGroupByUnqualified(relKeyFields) {
+  return relKeyFields.map((_, i) => `"__fk${i}"`).join(SQL_SEPARATORS.FIELD_LIST);
+}
+function buildJoinOnCondition(joinAlias, parentAlias, parentModel, parentKeyFields) {
+  const parts = parentKeyFields.map(
+    (f, i) => `${joinAlias}."__fk${i}" = ${parentAlias}.${quoteColumn(parentModel, f)}`
+  );
+  return parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`;
+}
+function buildPartitionBy(relAlias, relModel, relKeyFields) {
+  return relKeyFields.map((f) => `${relAlias}.${quoteColumn(relModel, f)}`).join(SQL_SEPARATORS.FIELD_LIST);
+}
+function hasNestedRelationInArgs(relArgs, relModel) {
+  if (!isPlainObject(relArgs)) return false;
+  const relationSet = getRelationFieldSet(relModel);
+  const checkSource = (src) => {
+    if (!isPlainObject(src)) return false;
+    for (const k of Object.keys(src)) {
+      if (relationSet.has(k) && src[k] !== false)
+        return true;
+    }
+    return false;
+  };
+  if (checkSource(relArgs.include)) return true;
+  if (checkSource(relArgs.select)) return true;
+  return false;
+}
+function canUseJoinInclude(dialect, isList, takeVal, skipVal, depth, outerHasLimit, hasNestedIncludes2) {
+  if (dialect !== "postgres") return false;
+  if (!isList) return false;
+  if (depth > 0) return false;
+  if (outerHasLimit) return false;
+  if (hasNestedIncludes2) return false;
+  if (isDynamicParameter(takeVal) || isDynamicParameter(skipVal)) return false;
+  return true;
+}
+function buildJoinBasedNonPaginated(args) {
+  const { relKeyFields, parentKeyFields } = resolveIncludeKeyPairs(args.field);
+  const joinAlias = args.ctx.aliasGen.next(`__inc_${args.relName}`);
+  const fkSelect = buildFkSelectList(args.relAlias, args.relModel, relKeyFields);
+  const fkGroupBy = buildPartitionBy(args.relAlias, args.relModel, relKeyFields);
+  const rowExpr = jsonBuildObject(args.relSelect, args.ctx.dialect);
+  const aggExpr = args.orderBySql ? `json_agg(${rowExpr} ORDER BY ${args.orderBySql})` : `json_agg(${rowExpr})`;
+  const joinsPart = args.whereJoins ? ` ${args.whereJoins}` : "";
+  const wherePart = args.rawWhereClause ? ` ${SQL_TEMPLATES.WHERE} ${args.rawWhereClause}` : "";
+  const subquery = `SELECT ${fkSelect}${SQL_SEPARATORS.FIELD_LIST}${aggExpr} AS __agg FROM ${args.relTable} ${args.relAlias}${joinsPart}${wherePart} GROUP BY ${fkGroupBy}`;
+  const onCondition = buildJoinOnCondition(
+    joinAlias,
+    args.ctx.parentAlias,
+    args.ctx.model,
+    parentKeyFields
+  );
+  const joinSql = `LEFT JOIN (${subquery}) ${joinAlias} ON ${onCondition}`;
+  const selectExpr = `COALESCE(${joinAlias}.__agg, '[]'::json) AS ${quote(args.relName)}`;
+  return Object.freeze({
+    name: args.relName,
+    sql: "",
+    isOneToOne: false,
+    joinSql,
+    selectExpr
+  });
+}
+function buildJoinBasedPaginated(args) {
+  const { relKeyFields, parentKeyFields } = resolveIncludeKeyPairs(args.field);
+  const joinAlias = args.ctx.aliasGen.next(`__inc_${args.relName}`);
+  const rankedAlias = args.ctx.aliasGen.next(`__ranked_${args.relName}`);
+  const fkSelect = buildFkSelectList(args.relAlias, args.relModel, relKeyFields);
+  const partitionBy = buildPartitionBy(
+    args.relAlias,
+    args.relModel,
+    relKeyFields
+  );
+  const rowExpr = jsonBuildObject(args.relSelect, args.ctx.dialect);
+  const orderExpr = args.orderBySql || `${args.relAlias}.${quoteColumn(args.relModel, "id")} ASC`;
+  const joinsPart = args.whereJoins ? ` ${args.whereJoins}` : "";
+  const wherePart = args.rawWhereClause ? ` ${SQL_TEMPLATES.WHERE} ${args.rawWhereClause}` : "";
+  const innerSql = `SELECT ${fkSelect}${SQL_SEPARATORS.FIELD_LIST}${rowExpr} AS __row${SQL_SEPARATORS.FIELD_LIST}ROW_NUMBER() OVER (PARTITION BY ${partitionBy} ORDER BY ${orderExpr}) AS __rn FROM ${args.relTable} ${args.relAlias}${joinsPart}${wherePart}`;
+  const scopeBase = buildIncludeScope(args.ctx.includePath);
+  const rnFilterParts = [];
+  if (isNotNullish(args.skipVal) && args.skipVal > 0) {
+    const skipPh = addAutoScoped(
+      args.ctx.params,
+      args.skipVal,
+      `${scopeBase}.skip`
+    );
+    rnFilterParts.push(`__rn > ${skipPh}`);
+    if (isNotNullish(args.takeVal)) {
+      const takePh = addAutoScoped(
+        args.ctx.params,
+        args.takeVal,
+        `${scopeBase}.take`
+      );
+      rnFilterParts.push(`__rn <= (${skipPh} + ${takePh})`);
+    }
+  } else if (isNotNullish(args.takeVal)) {
+    const takePh = addAutoScoped(
+      args.ctx.params,
+      args.takeVal,
+      `${scopeBase}.take`
+    );
+    rnFilterParts.push(`__rn <= ${takePh}`);
+  }
+  const rnFilter = rnFilterParts.length > 0 ? ` ${SQL_TEMPLATES.WHERE} ${rnFilterParts.join(SQL_SEPARATORS.CONDITION_AND)}` : "";
+  const fkGroupByOuter = buildFkGroupByUnqualified(relKeyFields);
+  const outerSql = `SELECT ${fkGroupByOuter}${SQL_SEPARATORS.FIELD_LIST}json_agg(__row ORDER BY __rn) AS __agg FROM (${innerSql}) ${rankedAlias}${rnFilter} GROUP BY ${fkGroupByOuter}`;
+  const onCondition = buildJoinOnCondition(
+    joinAlias,
+    args.ctx.parentAlias,
+    args.ctx.model,
+    parentKeyFields
+  );
+  const joinSql = `LEFT JOIN (${outerSql}) ${joinAlias} ON ${onCondition}`;
+  const selectExpr = `COALESCE(${joinAlias}.__agg, '[]'::json) AS ${quote(args.relName)}`;
+  return Object.freeze({
+    name: args.relName,
+    sql: "",
+    isOneToOne: false,
+    joinSql,
+    selectExpr
+  });
+}
 function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
   const relTable = getRelationTableReference(relModel, ctx.dialect);
   const relAlias = ctx.aliasGen.next(relName);
@@ -3283,6 +3525,48 @@ function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
     });
     return Object.freeze({ name: relName, sql, isOneToOne: true });
   }
+  const depth = ctx.depth || 0;
+  const outerHasLimit = ctx.outerHasLimit === true;
+  const nestedIncludes = hasNestedRelationInArgs(relArgs, relModel);
+  if (canUseJoinInclude(
+    ctx.dialect,
+    isList,
+    adjusted.takeVal,
+    paginationConfig.skipVal,
+    depth,
+    outerHasLimit,
+    nestedIncludes
+  )) {
+    const hasTakeOrSkip = isNotNullish(adjusted.takeVal) || isNotNullish(paginationConfig.skipVal);
+    if (!hasTakeOrSkip) {
+      return buildJoinBasedNonPaginated({
+        relName,
+        relTable,
+        relAlias,
+        relModel,
+        field,
+        whereJoins: whereParts.joins,
+        rawWhereClause: whereParts.rawClause,
+        orderBySql,
+        relSelect,
+        ctx
+      });
+    }
+    return buildJoinBasedPaginated({
+      relName,
+      relTable,
+      relAlias,
+      relModel,
+      field,
+      whereJoins: whereParts.joins,
+      rawWhereClause: whereParts.rawClause,
+      orderBySql,
+      relSelect,
+      takeVal: adjusted.takeVal,
+      skipVal: paginationConfig.skipVal,
+      ctx
+    });
+  }
   return buildListIncludeSpec({
     relName,
     relTable,
@@ -3352,14 +3636,14 @@ function buildIncludeSqlInternal(args, ctx) {
       buildSingleInclude(relName, relArgs, resolved.field, resolved.relModel, __spreadProps(__spreadValues({}, ctx), {
         includePath: nextIncludePath,
         visitPath: currentPath,
-        depth: depth + 1,
+        depth,
         stats
       }))
     );
   }
   return includes;
 }
-function buildIncludeSql(args, model, schemas, parentAlias, params, dialect) {
+function buildIncludeSql(args, model, schemas, parentAlias, params, dialect, outerHasLimit = true) {
   const aliasGen = createAliasGenerator();
   const stats = {
     totalIncludes: 0,
@@ -3379,7 +3663,8 @@ function buildIncludeSql(args, model, schemas, parentAlias, params, dialect) {
     includePath: [],
     visitPath: [],
     depth: 0,
-    stats
+    stats,
+    outerHasLimit
   });
 }
 function resolveCountRelationOrThrow(relName, model, schemaByName) {
@@ -3417,7 +3702,7 @@ function resolveCountRelationOrThrow(relName, model, schemaByName) {
 function defaultReferencesForCount(fkCount) {
   if (fkCount === 1) return ["id"];
   throw new Error(
-    "Relation count for composite keys requires explicit references matching foreignKey length"
+    "Relation count for composite keys requires explicit references matching..."
   );
 }
 function resolveCountKeyPairs(field) {
@@ -3526,6 +3811,307 @@ function joinNonEmpty(parts, sep) {
   }
   return result;
 }
+
+// src/builder/select/flat-join.ts
+function getPrimaryKeyField(model) {
+  const scalarSet = getScalarFieldSet(model);
+  for (const f of model.fields) {
+    if (f.isId && !f.isRelation && scalarSet.has(f.name)) {
+      return f.name;
+    }
+  }
+  if (scalarSet.has("id")) return "id";
+  throw new Error(
+    `Model ${model.name} has no primary key field. Models must have either a field with isId=true or a field named 'id'.`
+  );
+}
+function findPrimaryKeyFields(model) {
+  const pkFields = model.fields.filter((f) => f.isId && !f.isRelation);
+  if (pkFields.length > 0) return pkFields.map((f) => f.name);
+  const idField = model.fields.find((f) => f.name === "id" && !f.isRelation);
+  if (idField) return ["id"];
+  throw new Error(`Model ${model.name} has no primary key field`);
+}
+function getRelationModel(parentModel, relationName, schemas) {
+  const field = parentModel.fields.find((f) => f.name === relationName);
+  if (!(field == null ? void 0 : field.isRelation) || !field.relatedModel) {
+    throw new Error(`Invalid relation ${relationName} on ${parentModel.name}`);
+  }
+  const relModel = schemas.find((m) => m.name === field.relatedModel);
+  if (!relModel) {
+    throw new Error(`Related model ${field.relatedModel} not found`);
+  }
+  return relModel;
+}
+function extractIncludeSpecFromArgs(args, model) {
+  const includeSpec = {};
+  const relationSet = getRelationFieldSet(model);
+  if (args.include && isPlainObject(args.include)) {
+    for (const [key, value] of Object.entries(args.include)) {
+      if (value !== false) includeSpec[key] = value;
+    }
+  }
+  if (args.select && isPlainObject(args.select)) {
+    for (const [key, value] of Object.entries(args.select)) {
+      if (!relationSet.has(key)) continue;
+      if (value === false) continue;
+      if (value === true) {
+        includeSpec[key] = true;
+        continue;
+      }
+      if (isPlainObject(value)) {
+        const v = value;
+        if (isPlainObject(v.include) || isPlainObject(v.select)) {
+          includeSpec[key] = value;
+        }
+      }
+    }
+  }
+  return includeSpec;
+}
+function hasChildPagination(relArgs) {
+  if (!isPlainObject(relArgs)) return false;
+  const args = relArgs;
+  if (args.take !== void 0 && args.take !== null) return true;
+  if (args.skip !== void 0 && args.skip !== null) return true;
+  return false;
+}
+function extractNestedIncludeSpec(relArgs, relModel) {
+  const relationSet = getRelationFieldSet(relModel);
+  const out = {};
+  if (!isPlainObject(relArgs)) return out;
+  const obj = relArgs;
+  if (isPlainObject(obj.include)) {
+    for (const [k, v] of Object.entries(
+      obj.include
+    )) {
+      if (!relationSet.has(k)) continue;
+      if (v === false) continue;
+      out[k] = v;
+    }
+  }
+  if (isPlainObject(obj.select)) {
+    for (const [k, v] of Object.entries(
+      obj.select
+    )) {
+      if (!relationSet.has(k)) continue;
+      if (v === false) continue;
+      if (v === true) {
+        out[k] = true;
+        continue;
+      }
+      if (isPlainObject(v)) {
+        const vv = v;
+        if (isPlainObject(vv.include) || isPlainObject(vv.select)) {
+          out[k] = v;
+        }
+      }
+    }
+  }
+  return out;
+}
+function extractSelectedScalarFields(relArgs, relModel) {
+  const scalarFields = relModel.fields.filter((f) => !f.isRelation).map((f) => f.name);
+  const scalarSet = new Set(scalarFields);
+  if (relArgs === true || !isPlainObject(relArgs)) {
+    return { includeAllScalars: true, selected: scalarFields };
+  }
+  const obj = relArgs;
+  if (!isPlainObject(obj.select)) {
+    return { includeAllScalars: true, selected: scalarFields };
+  }
+  const sel = obj.select;
+  const selected = [];
+  for (const [k, v] of Object.entries(sel)) {
+    if (!scalarSet.has(k)) continue;
+    if (v === true) selected.push(k);
+  }
+  return { includeAllScalars: false, selected };
+}
+function uniqPreserveOrder(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const it of items) {
+    if (seen.has(it)) continue;
+    seen.add(it);
+    out.push(it);
+  }
+  return out;
+}
+function buildChildColumns(args) {
+  const { relModel, relationName, childAlias, prefix, relArgs } = args;
+  const fullPrefix = prefix ? `${prefix}.${relationName}` : relationName;
+  const pkFields = findPrimaryKeyFields(relModel);
+  const scalarSelection = extractSelectedScalarFields(relArgs, relModel);
+  const selectedScalar = scalarSelection.selected;
+  const required = uniqPreserveOrder([...pkFields, ...selectedScalar]);
+  const columns = [];
+  for (const fieldName of required) {
+    const field = relModel.fields.find(
+      (f) => f.name === fieldName && !f.isRelation
+    );
+    if (!field) continue;
+    const colName = field.dbName || field.name;
+    const quotedCol = quote(colName);
+    columns.push(`${childAlias}.${quotedCol} AS "${fullPrefix}.${field.name}"`);
+  }
+  return columns;
+}
+function canUseNestedFlatJoin(relArgs, depth) {
+  if (depth > 10) return false;
+  if (!isPlainObject(relArgs)) return true;
+  if (hasChildPagination(relArgs)) return false;
+  const obj = relArgs;
+  if (obj.include && isPlainObject(obj.include)) {
+    for (const childValue of Object.values(
+      obj.include
+    )) {
+      if (childValue !== false && !canUseNestedFlatJoin(childValue, depth + 1))
+        return false;
+    }
+  }
+  if (obj.select && isPlainObject(obj.select)) {
+    for (const childValue of Object.values(
+      obj.select
+    )) {
+      if (childValue !== false && !canUseNestedFlatJoin(childValue, depth + 1))
+        return false;
+    }
+  }
+  return true;
+}
+function canUseFlatJoinForAll(includeSpec) {
+  for (const value of Object.values(includeSpec)) {
+    if (value === false) continue;
+    if (!canUseNestedFlatJoin(value, 0)) return false;
+  }
+  return true;
+}
+function buildNestedJoins(parentModel, parentAlias, includeSpec, schemas, dialect, prefix, aliasCounter, depth = 0) {
+  if (depth > 10) {
+    throw new Error(
+      `Nested joins exceeded maximum depth of 10 at prefix '${prefix}'`
+    );
+  }
+  const joins = [];
+  const selects = [];
+  const orderBy = [];
+  for (const [relName, relValue] of Object.entries(includeSpec)) {
+    if (relValue === false) continue;
+    const field = parentModel.fields.find((f) => f.name === relName);
+    if (!isValidRelationField(field)) continue;
+    const relModel = getRelationModel(parentModel, relName, schemas);
+    const relTable = buildTableReference(
+      SQL_TEMPLATES.PUBLIC_SCHEMA,
+      relModel.tableName,
+      dialect
+    );
+    const childAlias = `fj_${aliasCounter.count++}`;
+    const joinCond = joinCondition(
+      field,
+      parentModel,
+      relModel,
+      parentAlias,
+      childAlias
+    );
+    joins.push(`LEFT JOIN ${relTable} ${childAlias} ON ${joinCond}`);
+    selects.push(
+      ...buildChildColumns({
+        relModel,
+        relationName: relName,
+        childAlias,
+        prefix,
+        relArgs: relValue
+      })
+    );
+    const childPkFields = findPrimaryKeyFields(relModel);
+    for (const pkField of childPkFields) {
+      orderBy.push(
+        `${childAlias}.${quoteColumn(relModel, pkField)} ASC NULLS LAST`
+      );
+    }
+    const nested = extractNestedIncludeSpec(relValue, relModel);
+    if (Object.keys(nested).length > 0) {
+      const nestedPrefix = prefix ? `${prefix}.${relName}` : relName;
+      const deeper = buildNestedJoins(
+        relModel,
+        childAlias,
+        nested,
+        schemas,
+        dialect,
+        nestedPrefix,
+        aliasCounter,
+        depth + 1
+      );
+      joins.push(...deeper.joins);
+      selects.push(...deeper.selects);
+      orderBy.push(...deeper.orderBy);
+    }
+  }
+  return { joins, selects, orderBy };
+}
+function buildFlatJoinSql(spec) {
+  const {
+    select,
+    from,
+    whereClause,
+    whereJoins,
+    orderBy,
+    dialect,
+    model,
+    schemas,
+    args
+  } = spec;
+  const includeSpec = extractIncludeSpecFromArgs(args, model);
+  if (Object.keys(includeSpec).length === 0) {
+    return { sql: "", requiresReduction: false, includeSpec: {} };
+  }
+  if (!canUseFlatJoinForAll(includeSpec)) {
+    return { sql: "", requiresReduction: false, includeSpec: {} };
+  }
+  const baseJoins = whereJoins.length > 0 ? whereJoins.join(" ") : "";
+  const baseWhere = whereClause && whereClause !== "1=1" ? `WHERE ${whereClause}` : "";
+  const baseOrderBy = orderBy ? `ORDER BY ${orderBy}` : "";
+  let baseSubquery = `
+    SELECT * FROM ${from.table} ${from.alias}
+    ${baseJoins}
+    ${baseWhere}
+    ${baseOrderBy}
+  `.trim();
+  baseSubquery = appendPagination(baseSubquery, spec);
+  const aliasCounter = { count: 0 };
+  const built = buildNestedJoins(
+    model,
+    from.alias,
+    includeSpec,
+    schemas,
+    dialect,
+    "",
+    aliasCounter,
+    0
+  );
+  if (built.joins.length === 0) {
+    return { sql: "", requiresReduction: false, includeSpec: {} };
+  }
+  const baseSelect = (select != null ? select : "").trim();
+  const allSelects = [baseSelect, ...built.selects].filter((s) => s && s.trim().length > 0).join(SQL_SEPARATORS.FIELD_LIST);
+  if (!allSelects) {
+    throw new Error("Flat-join SELECT requires at least one selected field");
+  }
+  const pkField = getPrimaryKeyField(model);
+  const orderByParts = [];
+  if (orderBy) orderByParts.push(orderBy);
+  orderByParts.push(`${from.alias}.${quoteColumn(model, pkField)} ASC`);
+  orderByParts.push(...built.orderBy);
+  const finalOrderBy = orderByParts.join(", ");
+  const sql = `
+    SELECT ${allSelects}
+    FROM (${baseSubquery}) ${from.alias}
+    ${built.joins.join(" ")}
+    ORDER BY ${finalOrderBy}
+  `.trim();
+  return { sql, requiresReduction: true, includeSpec };
+}
 function buildWhereSql(conditions) {
   if (!isNonEmptyArray(conditions)) return "";
   return " " + SQL_TEMPLATES.WHERE + " " + conditions.join(SQL_SEPARATORS.CONDITION_AND);
@@ -3560,9 +4146,6 @@ function finalizeSql(sql, params, dialect) {
     paramMappings: snapshot.mappings
   };
 }
-function isIdent(s) {
-  return /^[A-Za-z_]\w*$/.test(s);
-}
 function skipSpaces(s, i) {
   while (i < s.length) {
     const c = s.charCodeAt(i);
@@ -3656,11 +4239,6 @@ function parseSelectField(p, fromAlias) {
   i = skipSpaces(p, i);
   const a = readIdentOrQuoted(p, i);
   const actualAlias = a.text.toLowerCase();
-  if (!isIdent(a.text)) {
-    throw new Error(
-      `sqlite distinct emulation requires scalar select fields to be simple columns (alias.column). Got: ${p}`
-    );
-  }
   if (actualAlias !== fromLower) {
     throw new Error(`Expected alias '${fromAlias}', got '${a.text}' in: ${p}`);
   }
@@ -3729,10 +4307,10 @@ function extractDistinctOrderEntries(spec) {
         const value = item[field];
         if (typeof value === "string") {
           entries.push({ field, direction: value });
-        } else {
-          const obj = value;
-          entries.push({ field, direction: obj.sort, nulls: obj.nulls });
+          continue;
         }
+        const obj = value;
+        entries.push({ field, direction: obj.direction, nulls: obj.nulls });
       }
     }
     if (entries.length > 0) return entries;
@@ -3866,19 +4444,43 @@ function buildIncludeColumns(spec) {
   const hasIncludes = isNonEmptyArray(includes);
   const hasCountCols = isNonEmptyString(countCols);
   if (!hasIncludes && !hasCountCols) {
-    return { includeCols: "", selectWithIncludes: baseSelect, countJoins: [] };
+    return {
+      includeCols: "",
+      selectWithIncludes: baseSelect,
+      countJoins: [],
+      includeJoins: []
+    };
   }
   const emptyJson = dialect === "postgres" ? `'[]'::json` : `json('[]')`;
-  const includeCols = hasIncludes ? includes.map((inc) => {
-    const expr = inc.isOneToOne ? "(" + inc.sql + ")" : "COALESCE((" + inc.sql + "), " + emptyJson + ")";
-    return expr + " " + SQL_TEMPLATES.AS + " " + quote(inc.name);
-  }).join(SQL_SEPARATORS.FIELD_LIST) : "";
-  const allCols = joinNonEmpty(
-    [includeCols, countCols],
+  const correlatedParts = [];
+  const joinIncludeJoins = [];
+  const joinIncludeSelects = [];
+  if (hasIncludes) {
+    for (const inc of includes) {
+      if (inc.joinSql && inc.selectExpr) {
+        joinIncludeJoins.push(inc.joinSql);
+        joinIncludeSelects.push(inc.selectExpr);
+      } else {
+        const expr = inc.isOneToOne ? "(" + inc.sql + ")" : "COALESCE((" + inc.sql + "), " + emptyJson + ")";
+        correlatedParts.push(
+          expr + " " + SQL_TEMPLATES.AS + " " + quote(inc.name)
+        );
+      }
+    }
+  }
+  const correlatedCols = correlatedParts.join(SQL_SEPARATORS.FIELD_LIST);
+  const joinSelectCols = joinIncludeSelects.join(SQL_SEPARATORS.FIELD_LIST);
+  const allIncludeCols = joinNonEmpty(
+    [correlatedCols, joinSelectCols, countCols],
     SQL_SEPARATORS.FIELD_LIST
   );
-  const selectWithIncludes = buildSelectList(baseSelect, allCols);
-  return { includeCols: allCols, selectWithIncludes, countJoins };
+  const selectWithIncludes = buildSelectList(baseSelect, allIncludeCols);
+  return {
+    includeCols: allIncludeCols,
+    selectWithIncludes,
+    countJoins,
+    includeJoins: joinIncludeJoins
+  };
 }
 function appendPagination(sql, spec) {
   const { method, pagination, params } = spec;
@@ -3916,9 +4518,13 @@ function appendPagination(sql, spec) {
   return parts.join(" ");
 }
 function hasWindowDistinct(spec) {
+  if (spec.dialect !== "sqlite") return false;
   const d = spec.distinct;
   return isNotNullish(d) && isNonEmptyArray(d);
 }
+function hasAnyDistinct(spec) {
+  return isNotNullish(spec.distinct) && isNonEmptyArray(spec.distinct);
+}
 function assertDistinctAllowed(method, enabled) {
   if (enabled && method !== "findMany") {
     throw new Error(
@@ -3926,11 +4532,6 @@ function assertDistinctAllowed(method, enabled) {
     );
   }
 }
-function assertHasSelectFields(baseSelect, includeCols) {
-  if (!isNonEmptyString(baseSelect) && !isNonEmptyString(includeCols)) {
-    throw new Error("SELECT requires at least one selected field or include");
-  }
-}
 function withCountJoins(spec, countJoins, whereJoins) {
   return __spreadProps(__spreadValues({}, spec), {
     whereJoins: [...whereJoins || [], ...countJoins || []]
@@ -3957,6 +4558,63 @@ function pushWhere(parts, conditions) {
   if (!isNonEmptyArray(conditions)) return;
   parts.push(SQL_TEMPLATES.WHERE, conditions.join(SQL_SEPARATORS.CONDITION_AND));
 }
+function extractIncludeSpec(args) {
+  const includeSpec = {};
+  if (args.include && isPlainObject(args.include)) {
+    for (const [key, value] of Object.entries(args.include)) {
+      if (value !== false) {
+        includeSpec[key] = value;
+      }
+    }
+  }
+  if (args.select && isPlainObject(args.select)) {
+    for (const [key, value] of Object.entries(args.select)) {
+      if (value !== false && value !== true && isPlainObject(value)) {
+        const selectVal = value;
+        if (selectVal.include || selectVal.select) {
+          includeSpec[key] = value;
+        }
+      }
+    }
+  }
+  return includeSpec;
+}
+function hasNestedIncludes(includeSpec) {
+  return Object.keys(includeSpec).length > 0;
+}
+function splitOrderByTerms(orderBy) {
+  const raw = orderBy.trim();
+  if (raw.length === 0) return [];
+  return raw.split(SQL_SEPARATORS.ORDER_BY).map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function hasIdInOrderBy(orderBy, fromAlias) {
+  const aliasLower = String(fromAlias).toLowerCase();
+  const terms = splitOrderByTerms(orderBy).map((t) => t.toLowerCase());
+  return terms.some(
+    (t) => t.startsWith(aliasLower + ".id ") || t.startsWith(aliasLower + '."id" ') || t === aliasLower + ".id" || t === aliasLower + '."id"'
+  );
+}
+function ensureIdTiebreakerOrderBy(orderBy, fromAlias, model) {
+  var _a, _b;
+  const idField = (_b = (_a = model == null ? void 0 : model.fields) == null ? void 0 : _a.find) == null ? void 0 : _b.call(
+    _a,
+    (f) => f.name === "id" && !f.isRelation
+  );
+  if (!idField) return orderBy;
+  if (hasIdInOrderBy(orderBy, fromAlias)) return orderBy;
+  const t = col(fromAlias, "id", model) + " ASC";
+  return isNonEmptyString(orderBy) ? orderBy + ", " + t : t;
+}
+function ensurePostgresDistinctOrderBy(args) {
+  const { orderBy, distinct, fromAlias, model } = args;
+  const distinctTerms = distinct.map((f) => col(fromAlias, f, model) + " ASC");
+  const existing = splitOrderByTerms(orderBy);
+  const canKeepAsIs = existing.length >= distinctTerms.length && distinctTerms.every(
+    (term, i) => existing[i].toLowerCase().startsWith(term.split(" ASC")[0].toLowerCase())
+  );
+  const merged = canKeepAsIs ? orderBy : [...distinctTerms, ...existing].join(SQL_SEPARATORS.ORDER_BY);
+  return ensureIdTiebreakerOrderBy(merged, fromAlias, model);
+}
 function constructFinalSql(spec) {
   const {
     select,
@@ -3970,15 +4628,36 @@ function constructFinalSql(spec) {
     cursorClause,
     params,
     dialect,
-    model
+    model,
+    includes,
+    schemas,
+    pagination,
+    args
   } = spec;
   const useWindowDistinct = hasWindowDistinct(spec);
   assertDistinctAllowed(method, useWindowDistinct);
-  const { includeCols, selectWithIncludes, countJoins } = buildIncludeColumns(spec);
+  const hasDistinct = hasAnyDistinct(spec);
+  assertDistinctAllowed(method, hasDistinct);
+  const includeSpec = extractIncludeSpec(args);
+  const hasIncludes = hasNestedIncludes(includeSpec);
+  const shouldUseFlatJoin = dialect === "postgres" && hasIncludes && canUseFlatJoinForAll(includeSpec);
+  if (shouldUseFlatJoin) {
+    const flatResult = buildFlatJoinSql(spec);
+    if (flatResult.sql) {
+      const baseSqlResult = finalizeSql(flatResult.sql, params, dialect);
+      return {
+        sql: baseSqlResult.sql,
+        params: baseSqlResult.params,
+        paramMappings: baseSqlResult.paramMappings,
+        requiresReduction: true,
+        includeSpec: flatResult.includeSpec
+      };
+    }
+  }
+  const { includeCols, selectWithIncludes, countJoins, includeJoins } = buildIncludeColumns(spec);
   if (useWindowDistinct) {
-    const baseSelect2 = (select != null ? select : "").trim();
-    assertHasSelectFields(baseSelect2, includeCols);
-    const spec2 = withCountJoins(spec, countJoins, whereJoins);
+    const allExtraJoins = [...countJoins, ...includeJoins];
+    const spec2 = withCountJoins(spec, allExtraJoins, whereJoins);
     let sql2 = buildSqliteDistinctQuery(spec2, selectWithIncludes).trim();
     sql2 = appendPagination(sql2, spec);
     return finalizeSql(sql2, params, dialect);
@@ -4000,9 +4679,22 @@ function constructFinalSql(spec) {
     parts.push("CROSS JOIN", cteName);
   }
   pushJoinGroups(parts, whereJoins, countJoins);
+  if (isNonEmptyArray(includeJoins)) {
+    parts.push(includeJoins.join(" "));
+  }
   const conditions = buildConditions(whereClause, cursorClause);
   pushWhere(parts, conditions);
-  if (isNonEmptyString(orderBy)) parts.push(SQL_TEMPLATES.ORDER_BY, orderBy);
+  let finalOrderBy = orderBy;
+  if (dialect === "postgres" && isNonEmptyArray(distinct)) {
+    finalOrderBy = ensurePostgresDistinctOrderBy({
+      orderBy: orderBy || "",
+      distinct: [...distinct],
+      fromAlias: from.alias,
+      model
+    });
+  }
+  if (isNonEmptyString(finalOrderBy))
+    parts.push(SQL_TEMPLATES.ORDER_BY, finalOrderBy);
   let sql = parts.join(" ").trim();
   sql = appendPagination(sql, spec);
   return finalizeSql(sql, params, dialect);
@@ -4156,13 +4848,15 @@ function buildSelectSpec(input) {
     whereResult.paramMappings,
     whereResult.nextParamIndex
   );
+  const outerHasLimit = isNotNullish(take);
   const includes = buildIncludeSql(
     normalizedArgs,
     model,
     schemas,
     alias,
     params,
-    dialect
+    dialect,
+    outerHasLimit
   );
   const cursorResult = buildCursorClauseIfAny({
     cursor,
@@ -4342,6 +5036,14 @@ function buildInComparison(expr, op, val, params, dialect) {
   if (val.length === 0) {
     return op === Ops.IN ? "0=1" : "1=1";
   }
+  if (dialect === "sqlite" && val.length <= 30) {
+    const placeholders = [];
+    for (const item of val) {
+      placeholders.push(params.add(item));
+    }
+    const list = placeholders.join(", ");
+    return op === Ops.IN ? `${expr} IN (${list})` : `${expr} NOT IN (${list})`;
+  }
   const paramValue = prepareArrayParam(val, dialect);
   const placeholder = params.add(paramValue);
   return op === Ops.IN ? inArray(expr, placeholder, dialect) : notInArray(expr, placeholder, dialect);
@@ -4592,6 +5294,7 @@ function buildAggregateSql(args, whereResult, tableName, alias, model) {
     throw new Error("buildAggregateSql requires at least one aggregate field");
   }
   const selectClause = aggFields.join(SQL_SEPARATORS.FIELD_LIST);
+  const joinsPart = whereResult.joins && whereResult.joins.length > 0 ? whereResult.joins.join(" ") : "";
   const whereClause = isValidWhereClause(whereResult.clause) ? SQL_TEMPLATES.WHERE + " " + whereResult.clause : "";
   const parts = [
     SQL_TEMPLATES.SELECT,
@@ -4600,6 +5303,7 @@ function buildAggregateSql(args, whereResult, tableName, alias, model) {
     tableName,
     alias
   ];
+  if (joinsPart) parts.push(joinsPart);
   if (whereClause) parts.push(whereClause);
   const sql = parts.join(" ").trim();
   validateSelectQuery(sql);
@@ -4652,7 +5356,9 @@ function buildGroupBySql(args, whereResult, tableName, alias, model, dialect) {
     byFields
   );
   const havingClause = buildGroupByHaving(args, alias, params, model, d);
+  const joinsPart = whereResult.joins && whereResult.joins.length > 0 ? whereResult.joins.join(" ") : "";
   const whereClause = isValidWhereClause(whereResult.clause) ? SQL_TEMPLATES.WHERE + " " + whereResult.clause : "";
+  const orderBySql = isNotNullish(args.orderBy) ? buildOrderBy(args.orderBy, alias, d, model) : "";
   const parts = [
     SQL_TEMPLATES.SELECT,
     selectFields,
@@ -4660,9 +5366,21 @@ function buildGroupBySql(args, whereResult, tableName, alias, model, dialect) {
     tableName,
     alias
   ];
+  if (joinsPart) parts.push(joinsPart);
   if (whereClause) parts.push(whereClause);
   parts.push(SQL_TEMPLATES.GROUP_BY, groupFields);
   if (havingClause) parts.push(havingClause);
+  if (orderBySql) {
+    parts.push(SQL_TEMPLATES.ORDER_BY, orderBySql);
+  }
+  if (isNotNullish(args.take)) {
+    const ph = addAutoScoped(params, args.take, "groupBy.take");
+    parts.push(SQL_TEMPLATES.LIMIT, ph);
+  }
+  if (isNotNullish(args.skip)) {
+    const ph = addAutoScoped(params, args.skip, "groupBy.skip");
+    parts.push(SQL_TEMPLATES.OFFSET, ph);
+  }
   const sql = parts.join(" ").trim();
   const snapshot = params.snapshot();
   const allParams = [...whereResult.params, ...snapshot.params];
@@ -4675,32 +5393,25 @@ function buildGroupBySql(args, whereResult, tableName, alias, model, dialect) {
     paramMappings: allMappings
   };
 }
-function isPositiveInteger(value) {
-  return Number.isFinite(value) && Number.isInteger(value) && value > 0;
+function findPrimaryKeyFields2(model) {
+  const pkFields = model.fields.filter((f) => f.isId && !f.isRelation);
+  if (pkFields.length > 0) return pkFields.map((f) => f.name);
+  const defaultId = model.fields.find((f) => f.name === "id" && !f.isRelation);
+  if (defaultId) return ["id"];
+  return [];
 }
-function parseSkipValue(skip) {
-  return typeof skip === "string" ? Number(skip.trim()) : skip;
+function normalizeCountArgs(argsOrSkip) {
+  if (isPlainObject(argsOrSkip)) return argsOrSkip;
+  if (argsOrSkip === void 0 || argsOrSkip === null) return {};
+  return { skip: argsOrSkip };
 }
-function validateSkipParameter(skip) {
-  if (skip === void 0 || skip === null) {
-    return;
-  }
-  if (isDynamicParameter(skip)) {
-    throw new Error(
-      "count() with skip is not supported because it produces nondeterministic results. Dynamic skip cannot be validated at build time. Use findMany().length or add explicit orderBy + cursor/skip logic in a deterministic query."
-    );
-  }
-  const skipValue = parseSkipValue(skip);
-  if (isPositiveInteger(skipValue)) {
-    throw new Error(
-      "count() with skip is not supported because it produces nondeterministic results. Use findMany().length or add explicit orderBy to ensure deterministic behavior."
-    );
+function assertNoNegativeTake(args) {
+  if (typeof args.take === "number" && args.take < 0) {
+    throw new Error("Negative take is not supported for count()");
   }
 }
-function buildCountSql(whereResult, tableName, alias, skip, _dialect) {
-  assertSafeAlias(alias);
-  assertSafeTableRef(tableName);
-  validateSkipParameter(skip);
+function buildSimpleCountSql(whereResult, tableName, alias) {
+  const joinsPart = whereResult.joins && whereResult.joins.length > 0 ? whereResult.joins.join(" ") : "";
   const whereClause = isValidWhereClause(whereResult.clause) ? SQL_TEMPLATES.WHERE + " " + whereResult.clause : "";
   const parts = [
     SQL_TEMPLATES.SELECT,
@@ -4711,6 +5422,7 @@ function buildCountSql(whereResult, tableName, alias, skip, _dialect) {
     tableName,
     alias
   ];
+  if (joinsPart) parts.push(joinsPart);
   if (whereClause) parts.push(whereClause);
   const sql = parts.join(" ").trim();
   validateSelectQuery(sql);
@@ -4721,6 +5433,49 @@ function buildCountSql(whereResult, tableName, alias, skip, _dialect) {
     paramMappings: whereResult.paramMappings
   };
 }
+function buildCountSql(whereResult, tableName, alias, argsOrSkip, dialect, model, schemas) {
+  assertSafeAlias(alias);
+  assertSafeTableRef(tableName);
+  const args = normalizeCountArgs(argsOrSkip);
+  assertNoNegativeTake(args);
+  if (!model) {
+    return buildSimpleCountSql(whereResult, tableName, alias);
+  }
+  const pkFields = findPrimaryKeyFields2(model);
+  const distinctFields = isNonEmptyArray(args.distinct) ? args.distinct.map((x) => String(x)).filter((x) => x) : [];
+  const selectFields = distinctFields.length > 0 ? distinctFields : pkFields;
+  if (selectFields.length === 0) {
+    return buildSimpleCountSql(whereResult, tableName, alias);
+  }
+  const select = {};
+  for (const f of selectFields) select[f] = true;
+  const subArgs = __spreadProps(__spreadValues({}, args), {
+    include: void 0,
+    select
+  });
+  const d = dialect != null ? dialect : getGlobalDialect();
+  const subSchemas = Array.isArray(schemas) && schemas.length > 0 ? schemas : [model];
+  const sub = buildSelectSql({
+    method: "findMany",
+    args: subArgs,
+    model,
+    schemas: subSchemas,
+    from: { tableName, alias },
+    whereResult,
+    dialect: d
+  });
+  const countAlias = quote("__count_sub");
+  const sql = `${SQL_TEMPLATES.SELECT} ${SQL_TEMPLATES.COUNT_ALL} ${SQL_TEMPLATES.AS} ${quote(
+    "_count._all"
+  )} ${SQL_TEMPLATES.FROM} (${sub.sql}) ${SQL_TEMPLATES.AS} ${countAlias}`;
+  validateSelectQuery(sql);
+  validateParamConsistency(sql, sub.params);
+  return {
+    sql,
+    params: sub.params,
+    paramMappings: sub.paramMappings
+  };
+}
 function safeAlias(input) {
   const raw = String(input).toLowerCase();
   const cleaned = raw.replace(/[^a-z0-9_]/g, "_");
@@ -4732,6 +5487,17 @@ function safeAlias(input) {
   }
   return base;
 }
+function isPrismaMethod(v) {
+  return v === "findMany" || v === "findFirst" || v === "findUnique" || v === "aggregate" || v === "groupBy" || v === "count";
+}
+function resolveMethod(directive) {
+  var _a, _b;
+  const m = directive == null ? void 0 : directive.method;
+  if (isPrismaMethod(m)) return m;
+  const pm = (_b = (_a = directive == null ? void 0 : directive.query) == null ? void 0 : _a.processed) == null ? void 0 : _b.method;
+  if (isPrismaMethod(pm)) return pm;
+  return "findMany";
+}
 function buildSqlResult(args) {
   const {
     method,
@@ -4761,7 +5527,11 @@ function buildSqlResult(args) {
       whereResult,
       tableName,
       alias,
-      processed.skip);
+      processed,
+      dialect,
+      modelDef,
+      schemaModels
+    );
   }
   return buildSelectSql({
     method,
@@ -4849,7 +5619,43 @@ function buildMainWhere(args) {
     dialect
   });
 }
+function extractIncludeSpec2(processed, modelDef) {
+  const includeSpec = {};
+  const relationSet = new Set(
+    Array.isArray(modelDef == null ? void 0 : modelDef.fields) ? modelDef.fields.filter((f) => f && f.isRelation && typeof f.name === "string").map((f) => f.name) : []
+  );
+  if (processed.include && isPlainObject(processed.include)) {
+    for (const [key, value] of Object.entries(processed.include)) {
+      if (!relationSet.has(key)) continue;
+      if (value !== false) {
+        includeSpec[key] = value;
+      }
+    }
+  }
+  if (processed.select && isPlainObject(processed.select)) {
+    for (const [key, value] of Object.entries(processed.select)) {
+      if (!relationSet.has(key)) continue;
+      if (value === false) continue;
+      if (value === true) {
+        includeSpec[key] = true;
+        continue;
+      }
+      if (isPlainObject(value)) {
+        const selectVal = value;
+        if (selectVal.include || selectVal.select) {
+          includeSpec[key] = value;
+        } else {
+          includeSpec[key] = true;
+        }
+      } else {
+        includeSpec[key] = true;
+      }
+    }
+  }
+  return includeSpec;
+}
 function buildAndNormalizeSql(args) {
+  var _a;
   const {
     method,
     processed,
@@ -4870,14 +5676,30 @@ function buildAndNormalizeSql(args) {
     schemaModels,
     dialect
   });
-  return normalizeSqlAndMappingsForDialect(
+  const normalized = normalizeSqlAndMappingsForDialect(
     sqlResult.sql,
     sqlResult.paramMappings,
     dialect
   );
+  const includeSpec = (_a = sqlResult.includeSpec && isPlainObject(sqlResult.includeSpec) ? sqlResult.includeSpec : null) != null ? _a : extractIncludeSpec2(processed, modelDef);
+  const requiresReduction = sqlResult.requiresReduction === true;
+  return {
+    sql: normalized.sql,
+    paramMappings: normalized.paramMappings,
+    requiresReduction,
+    includeSpec
+  };
 }
 function finalizeDirective(args) {
-  const { directive, normalizedSql, normalizedMappings, dialect } = args;
+  const {
+    directive,
+    method,
+    normalizedSql,
+    normalizedMappings,
+    dialect,
+    requiresReduction,
+    includeSpec
+  } = args;
   const params = normalizedMappings.map((m) => {
     var _a;
     return (_a = m.value) != null ? _a : void 0;
@@ -4885,12 +5707,14 @@ function finalizeDirective(args) {
   validateParamConsistencyByDialect(normalizedSql, params, dialect);
   const { staticParams, dynamicKeys, paramOrder } = buildParamsFromMappings(normalizedMappings);
   return {
-    method: directive.method,
+    method,
     sql: normalizedSql,
     staticParams,
     dynamicKeys,
     paramOrder,
     paramMappings: normalizedMappings,
+    requiresReduction,
+    includeSpec,
     originalDirective: directive
   };
 }
@@ -4906,8 +5730,8 @@ function generateSQL(directive) {
     modelDef,
     dialect
   });
-  const method = directive.method;
-  const normalized = buildAndNormalizeSql({
+  const method = resolveMethod(directive);
+  const built = buildAndNormalizeSql({
     method,
     processed: query.processed,
     whereResult,
@@ -4919,9 +5743,12 @@ function generateSQL(directive) {
   });
   return finalizeDirective({
     directive,
-    normalizedSql: normalized.sql,
-    normalizedMappings: normalized.paramMappings,
-    dialect
+    method,
+    normalizedSql: built.sql,
+    normalizedMappings: built.paramMappings,
+    dialect,
+    requiresReduction: built.requiresReduction,
+    includeSpec: built.includeSpec
   });
 }
 
@@ -5509,7 +6336,9 @@ function buildSQLFull(model, models, method, args, dialect) {
         whereResult,
         tableName,
         alias,
-        args.skip);
+        args.skip,
+        dialect
+      );
       break;
     default:
       result = buildSelectSql({
@@ -5522,14 +6351,25 @@ function buildSQLFull(model, models, method, args, dialect) {
         dialect
       });
   }
-  return dialect === "sqlite" ? toSqliteParams(result.sql, result.params) : { sql: result.sql, params: [...result.params] };
+  const sqlResult = dialect === "sqlite" ? toSqliteParams(result.sql, result.params) : { sql: result.sql, params: [...result.params] };
+  return __spreadProps(__spreadValues({}, sqlResult), {
+    paramMappings: result.paramMappings,
+    requiresReduction: result.requiresReduction,
+    includeSpec: result.includeSpec
+  });
 }
 function buildSQLWithCache(model, models, method, args, dialect) {
   const cacheKey = canonicalizeQuery(model.name, method, args, dialect);
   const cached = queryCache.get(cacheKey);
   if (cached) {
     queryCacheStats.hit();
-    return { sql: cached.sql, params: [...cached.params] };
+    return {
+      sql: cached.sql,
+      params: [...cached.params],
+      paramMappings: cached.paramMappings,
+      requiresReduction: cached.requiresReduction,
+      includeSpec: cached.includeSpec
+    };
   }
   queryCacheStats.miss();
   const fastResult = tryFastPath(model, method, args, dialect);
@@ -5541,61 +6381,20 @@ function buildSQLWithCache(model, models, method, args, dialect) {
     return fastResult;
   }
   const result = buildSQLFull(model, models, method, args, dialect);
-  queryCache.set(cacheKey, { sql: result.sql, params: [...result.params] });
+  queryCache.set(cacheKey, {
+    sql: result.sql,
+    params: [...result.params],
+    paramMappings: result.paramMappings,
+    requiresReduction: result.requiresReduction,
+    includeSpec: result.includeSpec
+  });
   return result;
 }
 
 // src/result-transformers.ts
-function parseAggregateValue(value) {
-  if (typeof value === "string" && /^-?\d+(\.\d+)?$/.test(value)) {
-    return parseFloat(value);
-  }
-  return value;
-}
-function transformGroupByResults(results) {
-  return results.map((row) => {
-    const raw = row;
-    const parsed = {};
-    for (const [key, value] of Object.entries(raw)) {
-      const parts = key.split(".");
-      if (parts.length === 2) {
-        const [group, field] = parts;
-        if (!parsed[group]) parsed[group] = {};
-        parsed[group][field] = parseAggregateValue(value);
-      } else {
-        parsed[key] = value;
-      }
-    }
-    return parsed;
-  });
-}
-function transformCountResults(results) {
-  var _a, _b;
-  const result = results[0];
-  const count = (_b = (_a = result == null ? void 0 : result["_count._all"]) != null ? _a : result == null ? void 0 : result.count) != null ? _b : 0;
-  return typeof count === "string" ? parseInt(count, 10) : count;
-}
-function transformAggregateResults(results) {
-  const raw = results[0] || {};
-  const parsed = {};
-  for (const [key, value] of Object.entries(raw)) {
-    const parts = key.split(".");
-    if (parts.length === 2) {
-      const [group, field] = parts;
-      if (!parsed[group]) parsed[group] = {};
-      parsed[group][field] = parseAggregateValue(value);
-    } else {
-      parsed[key] = value;
-    }
-  }
-  return parsed;
-}
 var RESULT_TRANSFORMERS = {
   findFirst: (results) => results[0] || null,
-  findUnique: (results) => results[0] || null,
-  count: transformCountResults,
-  aggregate: transformAggregateResults,
-  groupBy: transformGroupByResults
+  findUnique: (results) => results[0] || null
 };
 function transformQueryResults(method, results) {
   const transformer = RESULT_TRANSFORMERS[method];
@@ -6518,6 +7317,321 @@ function createTransactionExecutor(deps) {
   };
 }
 
+// src/builder/select/reducer.ts
+var PK_FIELDS_CACHE = /* @__PURE__ */ new WeakMap();
+var SCALAR_FIELDS_CACHE = /* @__PURE__ */ new WeakMap();
+var JSON_FIELD_SET_CACHE = /* @__PURE__ */ new WeakMap();
+function findPrimaryKeyFieldsCached(model) {
+  const cached = PK_FIELDS_CACHE.get(model);
+  if (cached) return cached;
+  const pkFields = model.fields.filter((f) => f.isId && !f.isRelation);
+  if (pkFields.length > 0) {
+    const out = pkFields.map((f) => f.name);
+    PK_FIELDS_CACHE.set(model, out);
+    return out;
+  }
+  const defaultId = model.fields.find((f) => f.name === "id" && !f.isRelation);
+  if (defaultId) {
+    const out = ["id"];
+    PK_FIELDS_CACHE.set(model, out);
+    return out;
+  }
+  throw new Error(
+    `Model ${model.name} has no primary key field. Models must have either fields with isId=true or a field named 'id'.`
+  );
+}
+function scalarFieldNamesCached(model) {
+  const cached = SCALAR_FIELDS_CACHE.get(model);
+  if (cached) return cached;
+  const out = model.fields.filter((f) => !f.isRelation).map((f) => f.name);
+  SCALAR_FIELDS_CACHE.set(model, out);
+  return out;
+}
+function jsonFieldSetCached(model) {
+  var _a;
+  const cached = JSON_FIELD_SET_CACHE.get(model);
+  if (cached) return cached;
+  const s = /* @__PURE__ */ new Set();
+  for (const f of model.fields) {
+    if (f.isRelation) continue;
+    const t = String((_a = f.type) != null ? _a : "").toLowerCase();
+    if (t === "json") s.add(f.name);
+  }
+  JSON_FIELD_SET_CACHE.set(model, s);
+  return s;
+}
+function maybeParseJsonScalarFast(isJson, value) {
+  if (!isJson) return value;
+  if (value == null) return value;
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch (e) {
+    return value;
+  }
+}
+function extractIncludeSpecFromRelArgs(relArgs, relModel) {
+  const relationSet = getRelationFieldSet(relModel);
+  const out = {};
+  if (!isPlainObject(relArgs)) return out;
+  const obj = relArgs;
+  if (isPlainObject(obj.include)) {
+    for (const [k, v] of Object.entries(
+      obj.include
+    )) {
+      if (!relationSet.has(k)) continue;
+      if (v === false) continue;
+      out[k] = v;
+    }
+  }
+  if (isPlainObject(obj.select)) {
+    for (const [k, v] of Object.entries(
+      obj.select
+    )) {
+      if (!relationSet.has(k)) continue;
+      if (v === false) continue;
+      if (v === true) {
+        out[k] = true;
+        continue;
+      }
+      if (isPlainObject(v)) {
+        const vv = v;
+        if (isPlainObject(vv.include) || isPlainObject(vv.select)) {
+          out[k] = v;
+        }
+      }
+    }
+  }
+  return out;
+}
+function extractScalarSelection(relArgs, relModel) {
+  const scalars = scalarFieldNamesCached(relModel);
+  const scalarSet = new Set(scalars);
+  if (relArgs === true || !isPlainObject(relArgs)) {
+    return { includeAllScalars: true, selectedScalarFields: scalars };
+  }
+  const obj = relArgs;
+  if (!isPlainObject(obj.select)) {
+    return { includeAllScalars: true, selectedScalarFields: scalars };
+  }
+  const sel = obj.select;
+  const selected = [];
+  for (const [k, v] of Object.entries(sel)) {
+    if (!scalarSet.has(k)) continue;
+    if (v === true) selected.push(k);
+  }
+  return { includeAllScalars: false, selectedScalarFields: selected };
+}
+function buildRelationScalarCols(relModel, relPath, includeAllScalars, selectedScalarFields) {
+  const jsonSet = jsonFieldSetCached(relModel);
+  const scalarFields = includeAllScalars ? scalarFieldNamesCached(relModel) : selectedScalarFields;
+  const out = [];
+  for (const fieldName of scalarFields) {
+    out.push({
+      fieldName,
+      colName: `${relPath}.${fieldName}`,
+      isJson: jsonSet.has(fieldName)
+    });
+  }
+  return out;
+}
+function buildReducerConfig(parentModel, includeSpec, allModels, prefix = "", depth = 0) {
+  if (depth > 10) {
+    throw new Error(
+      `Reducer config exceeded maximum depth of 10 at path '${prefix}'`
+    );
+  }
+  const includedRelations = [];
+  const modelMap = new Map(allModels.map((m) => [m.name, m]));
+  for (const [incName, incValue] of Object.entries(includeSpec)) {
+    if (incValue === false) continue;
+    const field = parentModel.fields.find((f) => f.name === incName);
+    if (!field || !field.isRelation) {
+      throw new Error(
+        `Field '${incName}' is not a relation on model ${parentModel.name}`
+      );
+    }
+    const relatedModel = modelMap.get(field.relatedModel);
+    if (!relatedModel) {
+      throw new Error(
+        `Related model '${field.relatedModel}' not found for relation '${incName}'`
+      );
+    }
+    const isList = typeof field.type === "string" && field.type.endsWith("[]");
+    const primaryKeyFields = findPrimaryKeyFieldsCached(relatedModel);
+    const scalarSel = extractScalarSelection(incValue, relatedModel);
+    const relPath = prefix ? `${prefix}.${incName}` : incName;
+    let nestedIncludes = null;
+    const nestedSpec = extractIncludeSpecFromRelArgs(incValue, relatedModel);
+    if (Object.keys(nestedSpec).length > 0) {
+      nestedIncludes = buildReducerConfig(
+        relatedModel,
+        nestedSpec,
+        allModels,
+        relPath,
+        depth + 1
+      );
+    }
+    const keyCols = primaryKeyFields.map((f) => `${relPath}.${f}`);
+    const scalarCols = buildRelationScalarCols(
+      relatedModel,
+      relPath,
+      scalarSel.includeAllScalars,
+      scalarSel.selectedScalarFields
+    );
+    includedRelations.push({
+      name: incName,
+      cardinality: isList ? "many" : "one",
+      relatedModel,
+      primaryKeyFields,
+      includeAllScalars: scalarSel.includeAllScalars,
+      selectedScalarFields: scalarSel.selectedScalarFields,
+      nestedIncludes,
+      path: relPath,
+      keyCols,
+      scalarCols
+    });
+  }
+  return {
+    parentModel,
+    includedRelations,
+    allModels
+  };
+}
+function typedKeyPart(v) {
+  const t = typeof v;
+  if (t === "string") return `s:${v}`;
+  if (t === "number") return `n:${v}`;
+  if (t === "boolean") return `b:${v ? 1 : 0}`;
+  return `o:${String(v)}`;
+}
+function keyFromRowByCols(row, cols) {
+  if (cols.length === 0) return null;
+  if (cols.length === 1) {
+    const v = row[cols[0]];
+    if (v == null) return null;
+    return typedKeyPart(v);
+  }
+  let out = "";
+  for (let i = 0; i < cols.length; i++) {
+    const v = row[cols[i]];
+    if (v == null) return null;
+    if (i > 0) out += "";
+    out += typedKeyPart(v);
+  }
+  return out;
+}
+function getIndexForParent(store, parentObj, path) {
+  let byPath = store.get(parentObj);
+  if (!byPath) {
+    byPath = /* @__PURE__ */ new Map();
+    store.set(parentObj, byPath);
+  }
+  let idx = byPath.get(path);
+  if (!idx) {
+    idx = /* @__PURE__ */ new Map();
+    byPath.set(path, idx);
+  }
+  return idx;
+}
+function initNestedPlaceholders(obj, nested) {
+  if (!nested) return;
+  for (const r of nested.includedRelations) {
+    obj[r.name] = r.cardinality === "many" ? [] : null;
+  }
+}
+function materializeRelationObject(row, rel) {
+  const relKey = keyFromRowByCols(row, rel.keyCols);
+  if (relKey == null) return null;
+  const obj = {};
+  for (const c of rel.scalarCols) {
+    obj[c.fieldName] = maybeParseJsonScalarFast(c.isJson, row[c.colName]);
+  }
+  initNestedPlaceholders(obj, rel.nestedIncludes);
+  return obj;
+}
+function processRelation(parentObj, rel, row, manyStore) {
+  const relKey = keyFromRowByCols(row, rel.keyCols);
+  if (relKey == null) return;
+  if (rel.cardinality === "one") {
+    let current = parentObj[rel.name];
+    if (current == null) {
+      const created2 = materializeRelationObject(row, rel);
+      if (!created2) return;
+      parentObj[rel.name] = created2;
+      current = created2;
+    }
+    if (rel.nestedIncludes) {
+      for (const nestedRel of rel.nestedIncludes.includedRelations) {
+        processRelation(current, nestedRel, row, manyStore);
+      }
+    }
+    return;
+  }
+  const arr = parentObj[rel.name];
+  const idx = getIndexForParent(manyStore, parentObj, rel.path);
+  const existing = idx.get(relKey);
+  if (existing) {
+    if (rel.nestedIncludes) {
+      for (const nestedRel of rel.nestedIncludes.includedRelations) {
+        processRelation(existing, nestedRel, row, manyStore);
+      }
+    }
+    return;
+  }
+  const created = materializeRelationObject(row, rel);
+  if (!created) return;
+  arr.push(created);
+  idx.set(relKey, created);
+  if (rel.nestedIncludes) {
+    for (const nestedRel of rel.nestedIncludes.includedRelations) {
+      processRelation(created, nestedRel, row, manyStore);
+    }
+  }
+}
+function pickParentScalarFieldsFromRows(parentModel, rows) {
+  const all = scalarFieldNamesCached(parentModel);
+  if (rows.length === 0) return all;
+  const row0 = rows[0];
+  const picked = [];
+  for (const f of all) {
+    if (Object.prototype.hasOwnProperty.call(row0, f)) picked.push(f);
+  }
+  return picked.length > 0 ? picked : all;
+}
+function reduceFlatRows(rows, config) {
+  if (rows.length === 0) return [];
+  const { parentModel, includedRelations } = config;
+  const parentPkFields = findPrimaryKeyFieldsCached(parentModel);
+  const parentKeyCols = parentPkFields;
+  const parentScalarFields = pickParentScalarFieldsFromRows(parentModel, rows);
+  const parentJsonSet = jsonFieldSetCached(parentModel);
+  const resultMap = /* @__PURE__ */ new Map();
+  const manyStore = /* @__PURE__ */ new WeakMap();
+  for (const row of rows) {
+    const parentKey = keyFromRowByCols(row, parentKeyCols);
+    if (parentKey == null) continue;
+    let record = resultMap.get(parentKey);
+    if (!record) {
+      record = {};
+      for (const fieldName of parentScalarFields) {
+        record[fieldName] = maybeParseJsonScalarFast(
+          parentJsonSet.has(fieldName),
+          row[fieldName]
+        );
+      }
+      for (const rel of includedRelations) {
+        record[rel.name] = rel.cardinality === "many" ? [] : null;
+      }
+      resultMap.set(parentKey, record);
+    }
+    for (const rel of includedRelations) {
+      processRelation(record, rel, row, manyStore);
+    }
+  }
+  return Array.from(resultMap.values());
+}
+
 // src/index.ts
 function buildSQL(model, models, method, args, dialect) {
   return buildSQLWithCache(model, models, method, args, dialect);
@@ -6559,8 +7673,20 @@ function createPrismaSQL(config) {
   const modelMap = new Map(models.map((m) => [m.name, m]));
   function query(_0, _1) {
     return __async(this, arguments, function* (model, method, args = {}) {
-      const { sql, params } = toSQL(model, method, args);
-      return execute(client, sql, params);
+      const sqlResult = toSQL(model, method, args);
+      let results = yield execute(client, sqlResult.sql, [...sqlResult.params]);
+      if (sqlResult.requiresReduction && sqlResult.includeSpec) {
+        const modelDef = modelMap.get(model);
+        if (modelDef) {
+          const config2 = buildReducerConfig(
+            modelDef,
+            sqlResult.includeSpec,
+            models
+          );
+          results = reduceFlatRows(results, config2);
+        }
+      }
+      return transformQueryResults(method, results);
     });
   }
   function batchSql(queries) {
@@ -6609,6 +7735,6 @@ function generateSQLByModel(directives) {
   return byModel;
 }
 
-export { buildBatchCountSql, buildBatchSql, buildSQL, createPrismaSQL, createToSQL, createTransactionExecutor, generateAllSQL, generateSQL2 as generateSQL, generateSQLByModel, normalizeValue, parseBatchCountResults, parseBatchResults, transformQueryResults };
+export { buildBatchCountSql, buildBatchSql, buildReducerConfig, buildSQL, createPrismaSQL, createToSQL, createTransactionExecutor, generateAllSQL, generateSQL2 as generateSQL, generateSQLByModel, normalizeValue, parseBatchCountResults, parseBatchResults, reduceFlatRows, transformQueryResults };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map