@prisma-next/sql-orm-lane 0.1.0-pr.46.2 → 0.1.0-pr.47.2

package/dist/{chunk-AIYGMPVJ.js → chunk-KQPLODPT.js}

@@ -12,7 +12,6 @@ import {
   createDeleteAst,
   createInsertAst,
   createJoinOnExpr,
-  createNullCheckExpr,
   createOrderByItem,
   createParamRef,
   createSelectAst,
@@ -94,10 +93,10 @@ function errorMissingAlias(index) {
   throw planInvalid(`Missing alias at index ${index}`);
 }
 function errorMissingColumn(alias, index) {
-  throw planInvalid(`Missing column for alias "${alias}" at index ${index}`);
+  throw planInvalid(`Missing column for alias ${alias} at index ${index}`);
 }
 function errorInvalidColumn(alias, index) {
-  throw planInvalid(`Invalid column for alias "${alias}" at index ${index}`);
+  throw planInvalid(`Invalid column for alias ${alias} at index ${index}`);
 }
 function errorFailedToBuildWhereClause() {
   throw planInvalid("Failed to build WHERE clause");
@@ -114,115 +113,37 @@ function assertParameterExists(paramsMap, paramName) {
   return paramsMap[paramName];
 }
 
-// src/utils/guards.ts
-import { getColumnMeta, isParamPlaceholder } from "@prisma-next/sql-relational-core/utils/guards";
-function extractBaseColumnRef(expr) {
-  if (expr.kind === "col") {
-    return expr;
-  }
-  return extractBaseColumnRef(expr.self);
-}
-function collectColumnRefs(expr) {
-  if (expr.kind === "col") {
-    return [expr];
-  }
-  if (expr.kind === "operation") {
-    const refs = collectColumnRefs(expr.self);
-    for (const arg of expr.args) {
-      refs.push(...collectColumnRefs(arg));
-    }
-    return refs;
-  }
-  return [];
-}
-function isOperationExpr(expr) {
-  return expr != null && expr.kind === "operation";
-}
-function isExpressionBuilder(value) {
-  return typeof value === "object" && value !== null && "kind" in value && value.kind === "expression";
-}
-function extractExpression(builder) {
-  if (isExpressionBuilder(builder)) {
-    return builder.expr;
-  }
-  const colBuilder = builder;
-  return {
-    kind: "col",
-    table: colBuilder.table,
-    column: colBuilder.column
-  };
-}
-function getColumnInfo(expr) {
-  if (isExpressionBuilder(expr)) {
-    const baseCol = extractBaseColumnRef(expr.expr);
-    return { table: baseCol.table, column: baseCol.column };
-  }
-  const colBuilder = expr;
-  return { table: colBuilder.table, column: colBuilder.column };
-}
-function isColumnBuilder(value) {
-  return typeof value === "object" && value !== null && "kind" in value && value.kind === "column";
-}
-
 // src/selection/predicates.ts
 function buildWhereExpr(where, contract, paramsMap, descriptors, values) {
-  if (where.kind === "nullCheck") {
-    const expr = extractExpression(where.expr);
-    return {
-      expr: createNullCheckExpr(where.op, expr),
-      paramName: ""
-    };
+  const placeholder = where.right;
+  const paramName = placeholder.name;
+  if (!Object.hasOwn(paramsMap, paramName)) {
+    errorMissingParameter(paramName);
   }
+  const value = paramsMap[paramName];
+  const index = values.push(value);
   let leftExpr;
   let codecId;
-  let rightExpr;
-  let paramName;
-  leftExpr = extractExpression(where.left);
-  if (leftExpr.kind === "col") {
-    const contractTable = contract.storage.tables[leftExpr.table];
-    if (!contractTable) {
-      errorUnknownTable(leftExpr.table);
-    }
-    const columnMeta = contractTable.columns[leftExpr.column];
-    if (columnMeta) {
-      codecId = columnMeta.codecId;
-    }
-  }
-  if (isParamPlaceholder(where.right)) {
-    const placeholder = where.right;
-    paramName = placeholder.name;
-    if (!Object.hasOwn(paramsMap, paramName)) {
-      errorMissingParameter(paramName);
-    }
-    const value = paramsMap[paramName];
-    const index = values.push(value);
-    if (leftExpr.kind === "col") {
-      const contractTable = contract.storage.tables[leftExpr.table];
-      const columnMeta = contractTable?.columns[leftExpr.column];
-      const builderColumnMeta = isColumnBuilder(where.left) ? getColumnMeta(where.left) : isExpressionBuilder(where.left) ? where.left.columnMeta : void 0;
-      descriptors.push({
-        name: paramName,
-        source: "dsl",
-        refs: { table: leftExpr.table, column: leftExpr.column },
-        // Only include nullable if builderColumnMeta has it (don't fall back to contract)
-        ...typeof builderColumnMeta?.nullable === "boolean" ? { nullable: builderColumnMeta.nullable } : {}
-      });
-      augmentDescriptorWithColumnMeta(descriptors, columnMeta);
-    }
-    rightExpr = createParamRef(index, paramName);
-  } else if (isColumnBuilder(where.right)) {
-    const { table, column } = getColumnInfo(where.right);
-    const contractTable = contract.storage.tables[table];
-    if (!contractTable) {
-      errorUnknownTable(table);
-    }
-    rightExpr = createColumnRef(table, column);
-    paramName = "";
+  const operationExpr = where.left._operationExpr;
+  if (operationExpr) {
+    leftExpr = operationExpr;
   } else {
-    errorFailedToBuildWhereClause();
+    const colBuilder = where.left;
+    const meta = colBuilder.columnMeta ?? {};
+    descriptors.push({
+      name: paramName,
+      source: "dsl",
+      refs: { table: colBuilder.table, column: colBuilder.column },
+      ...typeof meta.nullable === "boolean" ? { nullable: meta.nullable } : {}
+    });
+    const contractTable = contract.storage.tables[colBuilder.table];
+    const columnMeta = contractTable?.columns[colBuilder.column];
+    codecId = columnMeta?.codecId;
+    augmentDescriptorWithColumnMeta(descriptors, columnMeta);
+    leftExpr = createColumnRef(colBuilder.table, colBuilder.column);
   }
   return {
-    expr: createBinaryExpr(where.op, leftExpr, rightExpr),
+    expr: createBinaryExpr(where.op, leftExpr, createParamRef(index, paramName)),
     ...codecId ? { codecId } : {},
     paramName
   };
@@ -669,13 +590,50 @@ var OrmRelationFilterBuilderImpl = class _OrmRelationFilterBuilderImpl {
 // src/plan/plan-assembly.ts
 import { planInvalid as planInvalid4 } from "@prisma-next/plan";
 import { compact } from "@prisma-next/sql-relational-core/ast";
+
+// src/utils/guards.ts
+function extractBaseColumnRef(expr) {
+  if (expr.kind === "col") {
+    return expr;
+  }
+  return extractBaseColumnRef(expr.self);
+}
+function collectColumnRefs(expr) {
+  if (expr.kind === "col") {
+    return [expr];
+  }
+  if (expr.kind === "operation") {
+    const refs = collectColumnRefs(expr.self);
+    for (const arg of expr.args) {
+      refs.push(...collectColumnRefs(arg));
+    }
+    return refs;
+  }
+  return [];
+}
+function isOperationExpr(expr) {
+  return typeof expr === "object" && expr !== null && "kind" in expr && expr.kind === "operation";
+}
+function getColumnInfo(expr) {
+  if (isOperationExpr(expr)) {
+    const baseCol = extractBaseColumnRef(expr);
+    return { table: baseCol.table, column: baseCol.column };
+  }
+  const colBuilder = expr;
+  return { table: colBuilder.table, column: colBuilder.column };
+}
+function isColumnBuilder(value) {
+  return typeof value === "object" && value !== null && "kind" in value && value.kind === "column";
+}
+
+// src/plan/plan-assembly.ts
 function buildMeta(args) {
   const refsColumns = /* @__PURE__ */ new Map();
   const refsTables = /* @__PURE__ */ new Set([args.table.name]);
   for (const column of args.projection.columns) {
-    const expr = extractExpression(column);
-    if (isOperationExpr(expr)) {
-      const allRefs = collectColumnRefs(expr);
+    const operationExpr = column._operationExpr;
+    if (operationExpr) {
+      const allRefs = collectColumnRefs(operationExpr);
       for (const ref of allRefs) {
         refsColumns.set(`${ref.table}.${ref.column}`, {
           table: ref.table,
@@ -683,10 +641,13 @@ function buildMeta(args) {
         });
       }
     } else {
-      refsColumns.set(`${expr.table}.${expr.column}`, {
-        table: expr.table,
-        column: expr.column
-      });
+      const col = column;
+      if (col.table && col.column) {
+        refsColumns.set(`${col.table}.${col.column}`, {
+          table: col.table,
+          column: col.column
+        });
+      }
     }
   }
   if (args.includes) {
@@ -714,24 +675,11 @@ function buildMeta(args) {
         }
       }
       if (include.childWhere) {
-        if (include.childWhere.kind === "binary") {
-          const colInfo = getColumnInfo(include.childWhere.left);
-          refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
-            table: colInfo.table,
-            column: colInfo.column
-          });
-        } else if (include.childWhere.kind === "nullCheck") {
-          const colInfo = getColumnInfo(include.childWhere.expr);
-          refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
-            table: colInfo.table,
-            column: colInfo.column
-          });
-        } else {
-          const _exhaustive = include.childWhere;
-          throw new Error(
-            `Unsupported predicate builder kind: ${_exhaustive.kind}`
-          );
-        }
+        const colInfo = getColumnInfo(include.childWhere.left);
+        refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
+          table: colInfo.table,
+          column: colInfo.column
+        });
       }
       if (include.childOrderBy) {
         const orderBy = include.childOrderBy;
@@ -746,24 +694,10 @@ function buildMeta(args) {
     }
   }
   if (args.where) {
-    let whereExprBuilder;
-    switch (args.where.kind) {
-      case "binary":
-        whereExprBuilder = args.where.left;
-        break;
-      case "nullCheck":
-        whereExprBuilder = args.where.expr;
-        break;
-      default: {
-        const _exhaustive = args.where;
-        throw new Error(
-          `Unsupported predicate builder kind: ${_exhaustive.kind}`
-        );
-      }
-    }
-    const expr = extractExpression(whereExprBuilder);
-    if (isOperationExpr(expr)) {
-      const allRefs = collectColumnRefs(expr);
+    const whereLeft = args.where.left;
+    const operationExpr = whereLeft._operationExpr;
+    if (operationExpr) {
+      const allRefs = collectColumnRefs(operationExpr);
       for (const ref of allRefs) {
         refsColumns.set(`${ref.table}.${ref.column}`, {
           table: ref.table,
@@ -771,19 +705,21 @@ function buildMeta(args) {
         });
       }
     } else {
-      refsColumns.set(`${expr.table}.${expr.column}`, {
-        table: expr.table,
-        column: expr.column
-      });
+      const colBuilder = whereLeft;
+      if (colBuilder.table && colBuilder.column) {
+        refsColumns.set(`${colBuilder.table}.${colBuilder.column}`, {
+          table: colBuilder.table,
+          column: colBuilder.column
+        });
+      }
     }
   }
   if (args.orderBy) {
     const orderBy = args.orderBy;
     const orderByExpr = orderBy.expr;
     if (orderByExpr) {
-      const expr = extractExpression(orderByExpr);
-      if (isOperationExpr(expr)) {
-        const allRefs = collectColumnRefs(expr);
+      if (isOperationExpr(orderByExpr)) {
+        const allRefs = collectColumnRefs(orderByExpr);
         for (const ref of allRefs) {
           refsColumns.set(`${ref.table}.${ref.column}`, {
             table: ref.table,
@@ -791,10 +727,13 @@ function buildMeta(args) {
           });
         }
       } else {
-        refsColumns.set(`${expr.table}.${expr.column}`, {
-          table: expr.table,
-          column: expr.column
-        });
+        const colBuilder = orderByExpr;
+        if (colBuilder.table && colBuilder.column) {
+          refsColumns.set(`${colBuilder.table}.${colBuilder.column}`, {
+            table: colBuilder.table,
+            column: colBuilder.column
+          });
+        }
       }
     }
   }
@@ -808,11 +747,15 @@ function buildMeta(args) {
       if (!column) {
         throw planInvalid4(`Missing column for alias ${alias} at index ${index}`);
       }
-      const expr = extractExpression(column);
-      if (isOperationExpr(expr)) {
-        return [alias, `operation:${expr.method}`];
+      const col = column;
+      if (!col.table || !col.column) {
+        return [alias, `include:${alias}`];
+      }
+      const operationExpr = col._operationExpr;
+      if (operationExpr) {
+        return [alias, `operation:${operationExpr.method}`];
       }
-      return [alias, `${expr.table}.${expr.column}`];
+      return [alias, `${col.table}.${col.column}`];
     })
   );
   const projectionTypes = {};
@@ -825,25 +768,19 @@ function buildMeta(args) {
     if (!col) {
       continue;
     }
-    const expr = extractExpression(col);
-    if (isOperationExpr(expr)) {
-      if (expr.returns.kind === "typeId") {
-        projectionTypes[alias] = expr.returns.type;
-      } else if (expr.returns.kind === "builtin") {
-        projectionTypes[alias] = expr.returns.type;
+    const operationExpr = col._operationExpr;
+    if (operationExpr) {
+      if (operationExpr.returns.kind === "typeId") {
+        projectionTypes[alias] = operationExpr.returns.type;
+      } else if (operationExpr.returns.kind === "builtin") {
+        projectionTypes[alias] = operationExpr.returns.type;
       }
     } else {
-      if (isExpressionBuilder(col)) {
-        const codecId = col.columnMeta.codecId;
-        if (codecId) {
-          projectionTypes[alias] = codecId;
-        }
-      } else {
-        const columnMeta = getColumnMeta(col);
-        const codecId = columnMeta?.codecId;
-        if (codecId) {
-          projectionTypes[alias] = codecId;
-        }
+      const colMeta = col;
+      const columnMeta = colMeta.columnMeta;
+      const codecId = columnMeta?.codecId;
+      if (codecId) {
+        projectionTypes[alias] = codecId;
       }
     }
   }
@@ -857,23 +794,17 @@ function buildMeta(args) {
     if (!column) {
       continue;
     }
-    const expr = extractExpression(column);
-    if (isOperationExpr(expr)) {
-      if (expr.returns.kind === "typeId") {
-        projectionCodecs[alias] = expr.returns.type;
+    const operationExpr = column._operationExpr;
+    if (operationExpr) {
+      if (operationExpr.returns.kind === "typeId") {
+        projectionCodecs[alias] = operationExpr.returns.type;
       }
     } else {
-      if (isExpressionBuilder(column)) {
-        const codecId = column.columnMeta.codecId;
-        if (codecId) {
-          projectionCodecs[alias] = codecId;
-        }
-      } else {
-        const columnMeta = getColumnMeta(column);
-        const codecId = columnMeta?.codecId;
-        if (codecId) {
-          projectionCodecs[alias] = codecId;
-        }
+      const col = column;
+      const columnMeta = col.columnMeta;
+      const codecId = columnMeta?.codecId;
+      if (codecId) {
+        projectionCodecs[alias] = codecId;
       }
     }
   }
@@ -930,7 +861,11 @@ function buildOrderByClause(orderBy) {
     return void 0;
   }
   const orderByBuilder = orderBy;
-  const expr = extractExpression(orderByBuilder.expr);
+  const orderExpr = orderByBuilder.expr;
+  const expr = isOperationExpr(orderExpr) ? orderExpr : (() => {
+    const colBuilder = orderExpr;
+    return createColumnRef(colBuilder.table, colBuilder.column);
+  })();
   return [createOrderByItem(expr, orderByBuilder.dir)];
 }
 function buildChildOrderByClause(orderBy) {
@@ -938,7 +873,15 @@ function buildChildOrderByClause(orderBy) {
     return void 0;
   }
   const orderByBuilder = orderBy;
-  const expr = extractExpression(orderByBuilder.expr);
+  const orderExpr = orderByBuilder.expr;
+  const expr = (() => {
+    if (isOperationExpr(orderExpr)) {
+      const baseCol = extractBaseColumnRef(orderExpr);
+      return createColumnRef(baseCol.table, baseCol.column);
+    }
+    const colBuilder = orderExpr;
+    return createColumnRef(colBuilder.table, colBuilder.column);
+  })();
   return [createOrderByItem(expr, orderByBuilder.dir)];
 }
 
@@ -974,7 +917,7 @@ function flattenProjection(projection, tracker, currentPath = []) {
   const columns = [];
   for (const [key, value] of Object.entries(projection)) {
     const path = [...currentPath, key];
-    if (isColumnBuilder(value) || isExpressionBuilder(value)) {
+    if (isColumnBuilder(value)) {
       const alias = tracker.register(path);
       aliases.push(alias);
       columns.push(value);
@@ -1009,7 +952,7 @@ function buildProjectionState(_table, projection, includes) {
           nullable: true
         }
       });
-    } else if (isColumnBuilder(value) || isExpressionBuilder(value)) {
+    } else if (isColumnBuilder(value)) {
       const alias = tracker.register([key]);
       aliases.push(alias);
       columns.push(value);
@@ -1110,8 +1053,13 @@ function buildIncludeAsts(includes, contract, context, modelName, paramsMap, par
       if (!column) {
         errorMissingColumn(alias, i);
       }
-      const expr = extractExpression(column);
-      childProjectionItems.push({ alias, expr });
+      const operationExpr = column._operationExpr;
+      if (operationExpr) {
+        childProjectionItems.push({ alias, expr: operationExpr });
+      } else {
+        const col = column;
+        childProjectionItems.push({ alias, expr: createColumnRef(col.table, col.column) });
+      }
     }
     const includeAst = compact2({
       kind: "includeMany",
@@ -1246,14 +1194,24 @@ function buildProjectionItems(projectionState, includesForMeta) {
         expr: { kind: "includeRef", alias }
       });
     } else {
-      const expr = extractExpression(column);
-      if (expr.kind === "col" && (!expr.table || !expr.column)) {
-        errorInvalidColumn(alias, i);
+      const operationExpr = column._operationExpr;
+      if (operationExpr) {
+        projectEntries.push({
+          alias,
+          expr: operationExpr
+        });
+      } else {
+        const col = column;
+        const tableName = col.table;
+        const columnName = col.column;
+        if (!tableName || !columnName) {
+          errorInvalidColumn(alias, i);
+        }
+        projectEntries.push({
+          alias,
+          expr: createColumnRef(tableName, columnName)
+        });
       }
-      projectEntries.push({
-        alias,
-        expr
-      });
     }
   }
   return projectEntries;
@@ -1758,4 +1716,4 @@ export {
   OrmModelBuilderImpl,
   orm
 };
-//# sourceMappingURL=chunk-AIYGMPVJ.js.map
+//# sourceMappingURL=chunk-KQPLODPT.js.map