@prisma-next/sql-lane 0.3.0-pr.99.1 → 0.3.0-pr.99.2

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

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