@prisma-next/sql-lane 0.3.0-pr.95.1 → 0.3.0-pr.96.1

package/dist/{chunk-72PNERR5.js → chunk-AWSKRSFP.js}

@@ -160,7 +160,7 @@ import { createJoinOnBuilder as createJoinOnBuilder2 } from "@prisma-next/sql-re
 
 // src/sql/mutation-builder.ts
 import {
-  createColumnRef,
+  createColumnRef as createColumnRef2,
   createDeleteAst,
   createInsertAst,
   createParamRef as createParamRef2,
@@ -246,7 +246,7 @@ function errorMissingParameter(paramName) {
 }
 function errorInvalidProjectionValue(path) {
   throw planInvalid2(
-    `Invalid projection value at path ${path.join(".")}: expected ExpressionSource (ColumnBuilder or ExpressionBuilder) or nested object`
+    `Invalid projection value at path ${path.join(".")}: expected ColumnBuilder or nested object`
   );
 }
 function errorIncludeAliasNotFound(alias) {
@@ -337,8 +337,9 @@ function checkReturningCapability(contract) {
 import { compact } from "@prisma-next/sql-relational-core/ast";
 import {
   collectColumnRefs,
+  getColumnInfo,
+  getOperationExpr,
   isColumnBuilder,
-  isExpressionBuilder,
   isOperationExpr
 } from "@prisma-next/sql-relational-core/utils/guards";
 
@@ -352,44 +353,28 @@ function assertColumnBuilder(col, context) {
 }
 
 // src/sql/plan.ts
-function collectRefsFromExpressionSource(source, refsColumns) {
-  if (isExpressionBuilder(source)) {
-    const allRefs = collectColumnRefs(source.expr);
-    for (const ref of allRefs) {
-      refsColumns.set(`${ref.table}.${ref.column}`, {
-        table: ref.table,
-        column: ref.column
-      });
-    }
-  } else if (isColumnBuilder(source)) {
-    const col = source;
-    refsColumns.set(`${col.table}.${col.column}`, {
-      table: col.table,
-      column: col.column
-    });
-  }
-}
-function collectRefsFromExpression(expr, refsColumns) {
-  if (isOperationExpr(expr)) {
-    const allRefs = collectColumnRefs(expr);
-    for (const ref of allRefs) {
-      refsColumns.set(`${ref.table}.${ref.column}`, {
-        table: ref.table,
-        column: ref.column
-      });
-    }
-  } else if (expr.kind === "col") {
-    refsColumns.set(`${expr.table}.${expr.column}`, {
-      table: expr.table,
-      column: expr.column
-    });
-  }
-}
 function buildMeta(args) {
   const refsColumns = /* @__PURE__ */ new Map();
   const refsTables = /* @__PURE__ */ new Set([args.table.name]);
   for (const column of args.projection.columns) {
-    collectRefsFromExpressionSource(column, refsColumns);
+    if (!column) {
+      continue;
+    }
+    const operationExpr = getOperationExpr(column);
+    if (operationExpr) {
+      const allRefs = collectColumnRefs(operationExpr);
+      for (const ref of allRefs) {
+        refsColumns.set(`${ref.table}.${ref.column}`, {
+          table: ref.table,
+          column: ref.column
+        });
+      }
+    } else {
+      refsColumns.set(`${column.table}.${column.column}`, {
+        table: column.table,
+        column: column.column
+      });
+    }
   }
   if (args.joins) {
     for (const join of args.joins) {
@@ -427,21 +412,36 @@ function buildMeta(args) {
         });
       }
       if (include.childWhere) {
-        collectRefsFromExpression(include.childWhere.left, refsColumns);
+        const colInfo = getColumnInfo(include.childWhere.left);
+        refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
+          table: colInfo.table,
+          column: colInfo.column
+        });
         const childWhereRight = include.childWhere.right;
-        if (isColumnBuilder(childWhereRight) || isExpressionBuilder(childWhereRight)) {
-          collectRefsFromExpressionSource(childWhereRight, refsColumns);
+        if (isColumnBuilder(childWhereRight)) {
+          const rightColInfo = getColumnInfo(childWhereRight);
+          refsColumns.set(`${rightColInfo.table}.${rightColInfo.column}`, {
+            table: rightColInfo.table,
+            column: rightColInfo.column
+          });
         }
       }
       if (include.childOrderBy) {
-        collectRefsFromExpression(include.childOrderBy.expr, refsColumns);
+        const orderBy = include.childOrderBy;
+        if (orderBy.expr) {
+          const colInfo = getColumnInfo(orderBy.expr);
+          refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
+            table: colInfo.table,
+            column: colInfo.column
+          });
+        }
       }
     }
   }
   if (args.where) {
-    const leftExpr = args.where.left;
-    if (isOperationExpr(leftExpr)) {
-      const allRefs = collectColumnRefs(leftExpr);
+    const whereLeft = args.where.left;
+    if (isOperationExpr(whereLeft)) {
+      const allRefs = collectColumnRefs(whereLeft);
       for (const ref of allRefs) {
         refsColumns.set(`${ref.table}.${ref.column}`, {
           table: ref.table,
@@ -449,31 +449,50 @@ function buildMeta(args) {
         });
       }
     } else {
-      refsColumns.set(`${leftExpr.table}.${leftExpr.column}`, {
-        table: leftExpr.table,
-        column: leftExpr.column
-      });
+      const operationExpr = whereLeft._operationExpr;
+      if (operationExpr) {
+        const allRefs = collectColumnRefs(operationExpr);
+        for (const ref of allRefs) {
+          refsColumns.set(`${ref.table}.${ref.column}`, {
+            table: ref.table,
+            column: ref.column
+          });
+        }
+      } else {
+        const colBuilder = assertColumnBuilder(whereLeft, "where clause must be a ColumnBuilder");
+        refsColumns.set(`${colBuilder.table}.${colBuilder.column}`, {
+          table: colBuilder.table,
+          column: colBuilder.column
+        });
+      }
     }
     const whereRight = args.where.right;
-    if (isColumnBuilder(whereRight) || isExpressionBuilder(whereRight)) {
-      collectRefsFromExpressionSource(whereRight, refsColumns);
+    if (isColumnBuilder(whereRight)) {
+      const colInfo = getColumnInfo(whereRight);
+      refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
+        table: colInfo.table,
+        column: colInfo.column
+      });
     }
   }
   if (args.orderBy) {
-    const orderByExpr = args.orderBy.expr;
-    if (isOperationExpr(orderByExpr)) {
-      const allRefs = collectColumnRefs(orderByExpr);
-      for (const ref of allRefs) {
-        refsColumns.set(`${ref.table}.${ref.column}`, {
-          table: ref.table,
-          column: ref.column
+    const orderBy = args.orderBy;
+    const orderByExpr = orderBy.expr;
+    if (orderByExpr) {
+      if (isOperationExpr(orderByExpr)) {
+        const allRefs = collectColumnRefs(orderByExpr);
+        for (const ref of allRefs) {
+          refsColumns.set(`${ref.table}.${ref.column}`, {
+            table: ref.table,
+            column: ref.column
+          });
+        }
+      } else {
+        refsColumns.set(`${orderByExpr.table}.${orderByExpr.column}`, {
+          table: orderByExpr.table,
+          column: orderByExpr.column
         });
       }
-    } else {
-      refsColumns.set(`${orderByExpr.table}.${orderByExpr.column}`, {
-        table: orderByExpr.table,
-        column: orderByExpr.column
-      });
     }
   }
   const includeAliases = new Set(args.includes?.map((inc) => inc.alias) ?? []);
@@ -486,14 +505,11 @@ function buildMeta(args) {
       if (!column) {
         errorMissingColumnForAlias(alias, index);
       }
-      if (isExpressionBuilder(column)) {
-        return [alias, `operation:${column.expr.method}`];
+      const operationExpr = getOperationExpr(column);
+      if (operationExpr) {
+        return [alias, `operation:${operationExpr.method}`];
       }
-      const col = column;
-      if (!col.table || !col.column) {
-        return [alias, `include:${alias}`];
-      }
-      return [alias, `${col.table}.${col.column}`];
+      return [alias, `${column.table}.${column.column}`];
     })
   );
   const projectionTypes = {};
@@ -506,8 +522,8 @@ function buildMeta(args) {
     if (!column) {
       continue;
     }
-    if (isExpressionBuilder(column)) {
-      const operationExpr = column.expr;
+    const operationExpr = column._operationExpr;
+    if (operationExpr) {
       if (operationExpr.returns.kind === "typeId") {
         projectionTypes[alias] = operationExpr.returns.type;
       } else if (operationExpr.returns.kind === "builtin") {
@@ -532,8 +548,8 @@ function buildMeta(args) {
     if (!column) {
       continue;
     }
-    if (isExpressionBuilder(column)) {
-      const operationExpr = column.expr;
+    const operationExpr = column._operationExpr;
+    if (operationExpr) {
       if (operationExpr.returns.kind === "typeId") {
         projectionCodecs[alias] = operationExpr.returns.type;
       }
@@ -570,10 +586,15 @@ function buildMeta(args) {
 }
 
 // src/sql/predicate-builder.ts
-import { createBinaryExpr, createParamRef } from "@prisma-next/sql-relational-core/ast";
 import {
+  createBinaryExpr,
+  createColumnRef,
+  createParamRef
+} from "@prisma-next/sql-relational-core/ast";
+import {
+  getColumnInfo as getColumnInfo2,
+  getOperationExpr as getOperationExpr2,
   isColumnBuilder as isColumnBuilder2,
-  isExpressionBuilder as isExpressionBuilder2,
   isParamPlaceholder
 } from "@prisma-next/sql-relational-core/utils/guards";
 function buildWhereExpr(contract, where, paramsMap, descriptors, values) {
@@ -581,13 +602,11 @@ function buildWhereExpr(contract, where, paramsMap, descriptors, values) {
   let codecId;
   let rightExpr;
   let paramName;
-  const validExpressionKinds = ["col", "operation"];
-  if (!where.left || typeof where.left !== "object" || !validExpressionKinds.includes(where.left.kind ?? "")) {
-    errorFailedToBuildWhereClause();
-  }
-  leftExpr = where.left;
-  if (leftExpr.kind === "col") {
-    const { table, column } = leftExpr;
+  const operationExpr = getOperationExpr2(where.left);
+  if (operationExpr) {
+    leftExpr = operationExpr;
+  } else if (isColumnBuilder2(where.left)) {
+    const { table, column } = getColumnInfo2(where.left);
     const contractTable = contract.storage.tables[table];
     if (!contractTable) {
       errorUnknownTable(table);
@@ -597,6 +616,9 @@ function buildWhereExpr(contract, where, paramsMap, descriptors, values) {
       errorUnknownColumn(column, table);
     }
     codecId = columnMeta.codecId;
+    leftExpr = createColumnRef(table, column);
+  } else {
+    errorFailedToBuildWhereClause();
   }
   if (isParamPlaceholder(where.right)) {
     const placeholder = where.right;
@@ -606,8 +628,8 @@ function buildWhereExpr(contract, where, paramsMap, descriptors, values) {
     }
     const value = paramsMap[paramName];
     const index = values.push(value);
-    if (leftExpr.kind === "col") {
-      const { table, column } = leftExpr;
+    if (isColumnBuilder2(where.left)) {
+      const { table, column } = getColumnInfo2(where.left);
       const contractTable = contract.storage.tables[table];
       const columnMeta = contractTable?.columns[column];
       if (columnMeta) {
@@ -622,19 +644,17 @@ function buildWhereExpr(contract, where, paramsMap, descriptors, values) {
       }
     }
     rightExpr = createParamRef(index, paramName);
-  } else if (isColumnBuilder2(where.right) || isExpressionBuilder2(where.right)) {
-    rightExpr = where.right.toExpr();
-    if (rightExpr.kind === "col") {
-      const { table, column } = rightExpr;
-      const contractTable = contract.storage.tables[table];
-      if (!contractTable) {
-        errorUnknownTable(table);
-      }
-      const columnMeta = contractTable.columns[column];
-      if (!columnMeta) {
-        errorUnknownColumn(column, table);
-      }
+  } else if (isColumnBuilder2(where.right)) {
+    const { table, column } = getColumnInfo2(where.right);
+    const contractTable = contract.storage.tables[table];
+    if (!contractTable) {
+      errorUnknownTable(table);
     }
+    const columnMeta = contractTable.columns[column];
+    if (!columnMeta) {
+      errorUnknownColumn(column, table);
+    }
+    rightExpr = createColumnRef(table, column);
     paramName = "";
   } else {
     errorFailedToBuildWhereClause();
@@ -708,7 +728,7 @@ var InsertBuilderImpl = class _InsertBuilderImpl {
     }
     const returning = this.returningColumns.map((col) => {
       const c = col;
-      return createColumnRef(c.table, c.column);
+      return createColumnRef2(c.table, c.column);
     });
     const ast = createInsertAst({
       table: createTableRef(this.table.name),
@@ -839,7 +859,7 @@ var UpdateBuilderImpl = class _UpdateBuilderImpl {
     }
     const returning = this.returningColumns.map((col) => {
       const c = col;
-      return createColumnRef(c.table, c.column);
+      return createColumnRef2(c.table, c.column);
     });
     const ast = createUpdateAst({
       table: createTableRef(this.table.name),
@@ -943,7 +963,7 @@ var DeleteBuilderImpl = class _DeleteBuilderImpl {
     }
     const returning = this.returningColumns.map((col) => {
       const c = col;
-      return createColumnRef(c.table, c.column);
+      return createColumnRef2(c.table, c.column);
     });
     const ast = createDeleteAst({
       table: createTableRef(this.table.name),
@@ -985,16 +1005,17 @@ var DeleteBuilderImpl = class _DeleteBuilderImpl {
 
 // src/sql/select-builder.ts
 import {
+  createColumnRef as createColumnRef5,
   createJoinOnBuilder,
   createOrderByItem as createOrderByItem2,
   createSelectAst,
   createTableRef as createTableRef4
 } from "@prisma-next/sql-relational-core/ast";
-import { isExpressionBuilder as isExpressionBuilder3 } from "@prisma-next/sql-relational-core/utils/guards";
+import { getOperationExpr as getOperationExpr3 } from "@prisma-next/sql-relational-core/utils/guards";
 
 // src/sql/include-builder.ts
 import {
-  createColumnRef as createColumnRef2,
+  createColumnRef as createColumnRef3,
   createJoinOnExpr,
   createOrderByItem,
   createTableRef as createTableRef2
@@ -1005,7 +1026,7 @@ import {
 } from "@prisma-next/sql-relational-core/utils/guards";
 
 // src/sql/projection.ts
-import { isExpressionSource } from "@prisma-next/sql-relational-core/utils/guards";
+import { isColumnBuilder as isColumnBuilder3 } from "@prisma-next/sql-relational-core/utils/guards";
 function generateAlias(path) {
   if (path.length === 0) {
     errorAliasPathEmpty();
@@ -1037,7 +1058,7 @@ function flattenProjection(projection, tracker, currentPath = []) {
   const columns = [];
   for (const [key, value] of Object.entries(projection)) {
     const path = [...currentPath, key];
-    if (isExpressionSource(value)) {
+    if (isColumnBuilder3(value)) {
       const alias = tracker.register(path);
       aliases.push(alias);
       columns.push(value);
@@ -1062,14 +1083,8 @@ function buildProjectionState(_table, projection, includes) {
         errorIncludeAliasNotFound(key);
       }
       aliases.push(key);
-      columns.push({
-        kind: "column",
-        table: matchingInclude.table.name,
-        column: "",
-        columnMeta: { nativeType: "jsonb", codecId: "core/json@1", nullable: true },
-        toExpr: () => ({ kind: "col", table: matchingInclude.table.name, column: "" })
-      });
-    } else if (isExpressionSource(value)) {
+      columns.push(null);
+    } else if (isColumnBuilder3(value)) {
       const alias = tracker.register([key]);
       aliases.push(alias);
       columns.push(value);
@@ -1199,10 +1214,10 @@ function buildIncludeAst(include, contract, paramsMap, paramDescriptors, paramVa
     const expr = (() => {
       if (isOperationExpr2(orderExpr)) {
         const baseCol = extractBaseColumnRef(orderExpr);
-        return createColumnRef2(baseCol.table, baseCol.column);
+        return createColumnRef3(baseCol.table, baseCol.column);
       }
       const colBuilder = orderExpr;
-      return createColumnRef2(colBuilder.table, colBuilder.column);
+      return createColumnRef3(colBuilder.table, colBuilder.column);
     })();
     return [createOrderByItem(expr, orderBy.dir)];
   })() : void 0;
@@ -1219,8 +1234,8 @@ function buildIncludeAst(include, contract, paramsMap, paramDescriptors, paramVa
   }
   const onLeft = include.on.left;
   const onRight = include.on.right;
-  const leftCol = createColumnRef2(onLeft.table, onLeft.column);
-  const rightCol = createColumnRef2(onRight.table, onRight.column);
+  const leftCol = createColumnRef3(onLeft.table, onLeft.column);
+  const rightCol = createColumnRef3(onRight.table, onRight.column);
   const onExpr = createJoinOnExpr(leftCol, rightCol);
   return {
     kind: "includeMany",
@@ -1238,7 +1253,7 @@ function buildIncludeAst(include, contract, paramsMap, paramDescriptors, paramVa
         }
         return {
           alias,
-          expr: column.toExpr()
+          expr: createColumnRef3(column.table, column.column)
         };
       })
     }
@@ -1247,7 +1262,7 @@ function buildIncludeAst(include, contract, paramsMap, paramDescriptors, paramVa
 
 // src/sql/join-builder.ts
 import {
-  createColumnRef as createColumnRef3,
+  createColumnRef as createColumnRef4,
   createJoin,
   createJoinOnExpr as createJoinOnExpr2,
   createTableRef as createTableRef3
@@ -1255,8 +1270,8 @@ import {
 function buildJoinAst(join) {
   const onLeft = join.on.left;
   const onRight = join.on.right;
-  const leftCol = createColumnRef3(onLeft.table, onLeft.column);
-  const rightCol = createColumnRef3(onRight.table, onRight.column);
+  const leftCol = createColumnRef4(onLeft.table, onLeft.column);
+  const rightCol = createColumnRef4(onRight.table, onRight.column);
   const onExpr = createJoinOnExpr2(leftCol, rightCol);
   return createJoin(join.joinType, createTableRef3(join.table.name), onExpr);
 }
@@ -1425,7 +1440,13 @@ var SelectBuilderImpl = class _SelectBuilderImpl {
     }
     const orderByClause = this.state.orderBy ? (() => {
       const orderBy = this.state.orderBy;
-      return [createOrderByItem2(orderBy.expr, orderBy.dir)];
+      const orderExpr = orderBy.expr;
+      const operationExpr = getOperationExpr3(orderExpr);
+      const expr = operationExpr ? operationExpr : (() => {
+        const colBuilder = orderExpr;
+        return createColumnRef5(colBuilder.table, colBuilder.column);
+      })();
+      return [createOrderByItem2(expr, orderBy.dir)];
     })() : void 0;
     const joins = this.state.joins?.map((join) => buildJoinAst(join));
     const includes = this.state.includes?.map(
@@ -1444,17 +1465,24 @@ var SelectBuilderImpl = class _SelectBuilderImpl {
           alias,
           expr: { kind: "includeRef", alias }
         });
-      } else if (column && isExpressionBuilder3(column)) {
-        projectEntries.push({
-          alias,
-          expr: column.expr
-        });
-      } else if (column) {
-        const columnRef = column.toExpr();
-        projectEntries.push({
-          alias,
-          expr: columnRef
-        });
+      } else {
+        if (!column) {
+          errorMissingColumnForAlias(alias, i);
+        }
+        const operationExpr = column._operationExpr;
+        if (operationExpr) {
+          projectEntries.push({
+            alias,
+            expr: operationExpr
+          });
+        } else {
+          const col = column;
+          assertColumnBuilder(col, "projection column");
+          projectEntries.push({
+            alias,
+            expr: createColumnRef5(col.table, col.column)
+          });
+        }
       }
     }
     const ast = createSelectAst({
@@ -1538,4 +1566,4 @@ export {
   createJoinOnBuilder2 as createJoinOnBuilder,
   sql
 };
-//# sourceMappingURL=chunk-72PNERR5.js.map
+//# sourceMappingURL=chunk-AWSKRSFP.js.map