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

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

@@ -12,6 +12,7 @@ import {
   createDeleteAst,
   createInsertAst,
   createJoinOnExpr,
+  createNullCheckExpr,
   createOrderByItem,
   createParamRef,
   createSelectAst,
@@ -93,10 +94,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");
@@ -113,37 +114,115 @@ 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) {
-  const placeholder = where.right;
-  const paramName = placeholder.name;
-  if (!Object.hasOwn(paramsMap, paramName)) {
-    errorMissingParameter(paramName);
+  if (where.kind === "nullCheck") {
+    const expr = extractExpression(where.expr);
+    return {
+      expr: createNullCheckExpr(where.op, expr),
+      paramName: ""
+    };
   }
-  const value = paramsMap[paramName];
-  const index = values.push(value);
   let leftExpr;
   let codecId;
-  const operationExpr = where.left._operationExpr;
-  if (operationExpr) {
-    leftExpr = operationExpr;
+  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 = "";
   } else {
-    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);
+    errorFailedToBuildWhereClause();
   }
   return {
-    expr: createBinaryExpr(where.op, leftExpr, createParamRef(index, paramName)),
+    expr: createBinaryExpr(where.op, leftExpr, rightExpr),
     ...codecId ? { codecId } : {},
     paramName
   };
@@ -590,50 +669,13 @@ 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 operationExpr = column._operationExpr;
-    if (operationExpr) {
-      const allRefs = collectColumnRefs(operationExpr);
+    const expr = extractExpression(column);
+    if (isOperationExpr(expr)) {
+      const allRefs = collectColumnRefs(expr);
       for (const ref of allRefs) {
         refsColumns.set(`${ref.table}.${ref.column}`, {
           table: ref.table,
@@ -641,13 +683,10 @@ function buildMeta(args) {
         });
       }
     } else {
-      const col = column;
-      if (col.table && col.column) {
-        refsColumns.set(`${col.table}.${col.column}`, {
-          table: col.table,
-          column: col.column
-        });
-      }
+      refsColumns.set(`${expr.table}.${expr.column}`, {
+        table: expr.table,
+        column: expr.column
+      });
     }
   }
   if (args.includes) {
@@ -675,11 +714,24 @@ function buildMeta(args) {
         }
       }
       if (include.childWhere) {
-        const colInfo = getColumnInfo(include.childWhere.left);
-        refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
-          table: colInfo.table,
-          column: colInfo.column
-        });
+        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}`
+          );
+        }
       }
       if (include.childOrderBy) {
         const orderBy = include.childOrderBy;
@@ -694,10 +746,24 @@ function buildMeta(args) {
     }
   }
   if (args.where) {
-    const whereLeft = args.where.left;
-    const operationExpr = whereLeft._operationExpr;
-    if (operationExpr) {
-      const allRefs = collectColumnRefs(operationExpr);
+    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);
       for (const ref of allRefs) {
         refsColumns.set(`${ref.table}.${ref.column}`, {
           table: ref.table,
@@ -705,21 +771,19 @@ function buildMeta(args) {
         });
       }
     } else {
-      const colBuilder = whereLeft;
-      if (colBuilder.table && colBuilder.column) {
-        refsColumns.set(`${colBuilder.table}.${colBuilder.column}`, {
-          table: colBuilder.table,
-          column: colBuilder.column
-        });
-      }
+      refsColumns.set(`${expr.table}.${expr.column}`, {
+        table: expr.table,
+        column: expr.column
+      });
     }
   }
   if (args.orderBy) {
     const orderBy = args.orderBy;
     const orderByExpr = orderBy.expr;
     if (orderByExpr) {
-      if (isOperationExpr(orderByExpr)) {
-        const allRefs = collectColumnRefs(orderByExpr);
+      const expr = extractExpression(orderByExpr);
+      if (isOperationExpr(expr)) {
+        const allRefs = collectColumnRefs(expr);
         for (const ref of allRefs) {
           refsColumns.set(`${ref.table}.${ref.column}`, {
             table: ref.table,
@@ -727,13 +791,10 @@ function buildMeta(args) {
           });
         }
       } else {
-        const colBuilder = orderByExpr;
-        if (colBuilder.table && colBuilder.column) {
-          refsColumns.set(`${colBuilder.table}.${colBuilder.column}`, {
-            table: colBuilder.table,
-            column: colBuilder.column
-          });
-        }
+        refsColumns.set(`${expr.table}.${expr.column}`, {
+          table: expr.table,
+          column: expr.column
+        });
       }
     }
   }
@@ -747,15 +808,11 @@ function buildMeta(args) {
       if (!column) {
         throw planInvalid4(`Missing column for alias ${alias} at index ${index}`);
       }
-      const col = column;
-      if (!col.table || !col.column) {
-        return [alias, `include:${alias}`];
-      }
-      const operationExpr = col._operationExpr;
-      if (operationExpr) {
-        return [alias, `operation:${operationExpr.method}`];
+      const expr = extractExpression(column);
+      if (isOperationExpr(expr)) {
+        return [alias, `operation:${expr.method}`];
       }
-      return [alias, `${col.table}.${col.column}`];
+      return [alias, `${expr.table}.${expr.column}`];
     })
   );
   const projectionTypes = {};
@@ -768,19 +825,25 @@ function buildMeta(args) {
     if (!col) {
       continue;
     }
-    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;
+    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;
       }
     } else {
-      const colMeta = col;
-      const columnMeta = colMeta.columnMeta;
-      const codecId = columnMeta?.codecId;
-      if (codecId) {
-        projectionTypes[alias] = codecId;
+      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;
+        }
       }
     }
   }
@@ -794,17 +857,23 @@ function buildMeta(args) {
     if (!column) {
       continue;
     }
-    const operationExpr = column._operationExpr;
-    if (operationExpr) {
-      if (operationExpr.returns.kind === "typeId") {
-        projectionCodecs[alias] = operationExpr.returns.type;
+    const expr = extractExpression(column);
+    if (isOperationExpr(expr)) {
+      if (expr.returns.kind === "typeId") {
+        projectionCodecs[alias] = expr.returns.type;
       }
     } else {
-      const col = column;
-      const columnMeta = col.columnMeta;
-      const codecId = columnMeta?.codecId;
-      if (codecId) {
-        projectionCodecs[alias] = codecId;
+      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;
+        }
       }
     }
   }
@@ -861,11 +930,7 @@ function buildOrderByClause(orderBy) {
     return void 0;
   }
   const orderByBuilder = orderBy;
-  const orderExpr = orderByBuilder.expr;
-  const expr = isOperationExpr(orderExpr) ? orderExpr : (() => {
-    const colBuilder = orderExpr;
-    return createColumnRef(colBuilder.table, colBuilder.column);
-  })();
+  const expr = extractExpression(orderByBuilder.expr);
   return [createOrderByItem(expr, orderByBuilder.dir)];
 }
 function buildChildOrderByClause(orderBy) {
@@ -873,15 +938,7 @@ function buildChildOrderByClause(orderBy) {
     return void 0;
   }
   const orderByBuilder = orderBy;
-  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);
-  })();
+  const expr = extractExpression(orderByBuilder.expr);
   return [createOrderByItem(expr, orderByBuilder.dir)];
 }
 
@@ -917,7 +974,7 @@ function flattenProjection(projection, tracker, currentPath = []) {
   const columns = [];
   for (const [key, value] of Object.entries(projection)) {
     const path = [...currentPath, key];
-    if (isColumnBuilder(value)) {
+    if (isColumnBuilder(value) || isExpressionBuilder(value)) {
       const alias = tracker.register(path);
       aliases.push(alias);
       columns.push(value);
@@ -952,7 +1009,7 @@ function buildProjectionState(_table, projection, includes) {
           nullable: true
         }
       });
-    } else if (isColumnBuilder(value)) {
+    } else if (isColumnBuilder(value) || isExpressionBuilder(value)) {
       const alias = tracker.register([key]);
       aliases.push(alias);
       columns.push(value);
@@ -1053,13 +1110,8 @@ function buildIncludeAsts(includes, contract, context, modelName, paramsMap, par
       if (!column) {
         errorMissingColumn(alias, i);
       }
-      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 expr = extractExpression(column);
+      childProjectionItems.push({ alias, expr });
     }
     const includeAst = compact2({
       kind: "includeMany",
@@ -1194,24 +1246,14 @@ function buildProjectionItems(projectionState, includesForMeta) {
         expr: { kind: "includeRef", alias }
       });
     } else {
-      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)
-        });
+      const expr = extractExpression(column);
+      if (expr.kind === "col" && (!expr.table || !expr.column)) {
+        errorInvalidColumn(alias, i);
       }
+      projectEntries.push({
+        alias,
+        expr
+      });
     }
   }
   return projectEntries;
@@ -1716,4 +1758,4 @@ export {
   OrmModelBuilderImpl,
   orm
 };
-//# sourceMappingURL=chunk-KQPLODPT.js.map
+//# sourceMappingURL=chunk-AIYGMPVJ.js.map