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

package/dist/{chunk-C4EECZ4E.js → chunk-3DNKIXXB.js}

@@ -5,8 +5,10 @@ import { schema as schema4 } from "@prisma-next/sql-relational-core/schema";
 // src/selection/predicates.ts
 import { augmentDescriptorWithColumnMeta } from "@prisma-next/sql-relational-core/plan";
 import {
+  getColumnInfo,
+  getColumnMeta,
+  getOperationExpr,
   isColumnBuilder,
-  isExpressionBuilder,
   isParamPlaceholder
 } from "@prisma-next/sql-relational-core/utils/guards";
 
@@ -124,9 +126,11 @@ function buildWhereExpr(where, contract, paramsMap, descriptors, values) {
   let codecId;
   let rightExpr;
   let paramName;
-  leftExpr = where.left;
-  if (leftExpr.kind === "col") {
-    const { table, column } = leftExpr;
+  const operationExpr = getOperationExpr(where.left);
+  if (operationExpr) {
+    leftExpr = operationExpr;
+  } else if (isColumnBuilder(where.left)) {
+    const { table, column } = getColumnInfo(where.left);
     const contractTable = contract.storage.tables[table];
     if (!contractTable) {
       errorUnknownTable(table);
@@ -135,6 +139,9 @@ function buildWhereExpr(where, contract, paramsMap, descriptors, values) {
     if (columnMeta) {
       codecId = columnMeta.codecId;
     }
+    leftExpr = createColumnRef(table, column);
+  } else {
+    errorFailedToBuildWhereClause();
   }
   if (isParamPlaceholder(where.right)) {
     const placeholder = where.right;
@@ -144,21 +151,27 @@ function buildWhereExpr(where, contract, paramsMap, descriptors, values) {
     }
     const value = paramsMap[paramName];
     const index = values.push(value);
-    if (leftExpr.kind === "col") {
-      const { table, column } = leftExpr;
+    if (isColumnBuilder(where.left)) {
+      const { table, column } = getColumnInfo(where.left);
       const contractTable = contract.storage.tables[table];
       const columnMeta = contractTable?.columns[column];
+      const builderColumnMeta = getColumnMeta(where.left);
       descriptors.push({
         name: paramName,
         source: "dsl",
         refs: { table, column },
-        ...columnMeta && typeof columnMeta.nullable === "boolean" ? { nullable: columnMeta.nullable } : {}
+        ...typeof builderColumnMeta?.nullable === "boolean" ? { nullable: builderColumnMeta.nullable } : {}
       });
       augmentDescriptorWithColumnMeta(descriptors, columnMeta);
     }
     rightExpr = createParamRef(index, paramName);
-  } else if (isColumnBuilder(where.right) || isExpressionBuilder(where.right)) {
-    rightExpr = where.right.toExpr();
+  } 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 {
     errorFailedToBuildWhereClause();
@@ -613,53 +626,32 @@ import { planInvalid as planInvalid4 } from "@prisma-next/plan";
 import { compact } from "@prisma-next/sql-relational-core/ast";
 import {
   collectColumnRefs,
-  getColumnMeta,
-  isColumnBuilder as isColumnBuilder2,
-  isExpressionBuilder as isExpressionBuilder2,
+  getColumnInfo as getColumnInfo2,
+  getColumnMeta as getColumnMeta2,
   isOperationExpr
 } from "@prisma-next/sql-relational-core/utils/guards";
-function collectRefsFromExpressionSource(source, refsColumns) {
-  if (isExpressionBuilder2(source)) {
-    const allRefs = collectColumnRefs(source.expr);
-    for (const ref of allRefs) {
-      if (ref.table && ref.column) {
+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);
+      for (const ref of allRefs) {
         refsColumns.set(`${ref.table}.${ref.column}`, {
           table: ref.table,
           column: ref.column
         });
       }
+    } else {
+      const col = column;
+      if (col.table && col.column) {
+        refsColumns.set(`${col.table}.${col.column}`, {
+          table: col.table,
+          column: col.column
+        });
+      }
     }
-  } else if (isColumnBuilder2(source)) {
-    const col = source;
-    if (col.table && col.column) {
-      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 (args.includes) {
     for (const include of args.includes) {
@@ -686,17 +678,29 @@ function buildMeta(args) {
         }
       }
       if (include.childWhere) {
-        collectRefsFromExpression(include.childWhere.left, refsColumns);
+        const colInfo = getColumnInfo2(include.childWhere.left);
+        refsColumns.set(`${colInfo.table}.${colInfo.column}`, {
+          table: colInfo.table,
+          column: colInfo.column
+        });
       }
       if (include.childOrderBy) {
-        collectRefsFromExpression(include.childOrderBy.expr, refsColumns);
+        const orderBy = include.childOrderBy;
+        if (orderBy.expr) {
+          const colInfo = getColumnInfo2(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;
+    const operationExpr = whereLeft._operationExpr;
+    if (operationExpr) {
+      const allRefs = collectColumnRefs(operationExpr);
       for (const ref of allRefs) {
         refsColumns.set(`${ref.table}.${ref.column}`, {
           table: ref.table,
@@ -704,27 +708,36 @@ function buildMeta(args) {
         });
       }
     } else {
-      refsColumns.set(`${leftExpr.table}.${leftExpr.column}`, {
-        table: leftExpr.table,
-        column: leftExpr.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 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 {
+        const colBuilder = orderByExpr;
+        if (colBuilder.table && colBuilder.column) {
+          refsColumns.set(`${colBuilder.table}.${colBuilder.column}`, {
+            table: colBuilder.table,
+            column: colBuilder.column
+          });
+        }
       }
-    } else {
-      refsColumns.set(`${orderByExpr.table}.${orderByExpr.column}`, {
-        table: orderByExpr.table,
-        column: orderByExpr.column
-      });
     }
   }
   const includeAliases = new Set(args.includes?.map((inc) => inc.alias) ?? []);
@@ -737,13 +750,14 @@ function buildMeta(args) {
       if (!column) {
         throw planInvalid4(`Missing column for alias ${alias} at index ${index}`);
       }
-      if (isExpressionBuilder2(column)) {
-        return [alias, `operation:${column.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, `${col.table}.${col.column}`];
     })
   );
@@ -757,15 +771,15 @@ function buildMeta(args) {
     if (!col) {
       continue;
     }
-    if (isExpressionBuilder2(col)) {
-      const operationExpr = col.expr;
+    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 {
-      const columnMeta = getColumnMeta(col);
+      const columnMeta = getColumnMeta2(col);
       const codecId = columnMeta?.codecId;
       if (codecId) {
         projectionTypes[alias] = codecId;
@@ -782,13 +796,13 @@ function buildMeta(args) {
     if (!column) {
       continue;
     }
-    if (isExpressionBuilder2(column)) {
-      const operationExpr = column.expr;
+    const operationExpr = column._operationExpr;
+    if (operationExpr) {
       if (operationExpr.returns.kind === "typeId") {
         projectionCodecs[alias] = operationExpr.returns.type;
       }
     } else {
-      const columnMeta = getColumnMeta(column);
+      const columnMeta = getColumnMeta2(column);
       const codecId = columnMeta?.codecId;
       if (codecId) {
         projectionCodecs[alias] = codecId;
@@ -821,7 +835,6 @@ function buildMeta(args) {
 // src/relations/include-plan.ts
 import { compact as compact2 } from "@prisma-next/sql-relational-core/ast";
 import { schema as schema3 } from "@prisma-next/sql-relational-core/schema";
-import { isExpressionBuilder as isExpressionBuilder4 } from "@prisma-next/sql-relational-core/utils/guards";
 
 // src/orm/capabilities.ts
 function checkIncludeCapabilities(contract) {
@@ -878,10 +891,7 @@ function buildChildOrderByClause(orderBy) {
 }
 
 // src/selection/projection.ts
-import {
-  isColumnBuilder as isColumnBuilder3,
-  isExpressionBuilder as isExpressionBuilder3
-} from "@prisma-next/sql-relational-core/utils/guards";
+import { isColumnBuilder as isColumnBuilder2 } from "@prisma-next/sql-relational-core/utils/guards";
 function generateAlias(path) {
   if (path.length === 0) {
     errorAliasPathEmpty();
@@ -913,7 +923,7 @@ function flattenProjection(projection, tracker, currentPath = []) {
   const columns = [];
   for (const [key, value] of Object.entries(projection)) {
     const path = [...currentPath, key];
-    if (isColumnBuilder3(value) || isExpressionBuilder3(value)) {
+    if (isColumnBuilder2(value)) {
       const alias = tracker.register(path);
       aliases.push(alias);
       columns.push(value);
@@ -946,12 +956,9 @@ function buildProjectionState(_table, projection, includes) {
           nativeType: "jsonb",
           codecId: "core/json@1",
           nullable: true
-        },
-        toExpr() {
-          return { kind: "col", table: matchingInclude.table.name, column: "" };
         }
       });
-    } else if (isColumnBuilder3(value) || isExpressionBuilder3(value)) {
+    } else if (isColumnBuilder2(value)) {
       const alias = tracker.register([key]);
       aliases.push(alias);
       columns.push(value);
@@ -1062,10 +1069,12 @@ function buildIncludeAsts(input) {
       if (!column) {
         errorMissingColumn(alias, i);
       }
-      if (isExpressionBuilder4(column)) {
-        childProjectionItems.push({ alias, expr: column.expr });
+      const operationExpr = column._operationExpr;
+      if (operationExpr) {
+        childProjectionItems.push({ alias, expr: operationExpr });
       } else {
-        childProjectionItems.push({ alias, expr: column.toExpr() });
+        const col = column;
+        childProjectionItems.push({ alias, expr: createColumnRef(col.table, col.column) });
       }
     }
     const includeAst = compact2({
@@ -1183,7 +1192,6 @@ function combineWhereClauses(mainWhere, existsExprs) {
 }
 
 // src/selection/select-builder.ts
-import { isExpressionBuilder as isExpressionBuilder5 } from "@prisma-next/sql-relational-core/utils/guards";
 function buildProjectionItems(projectionState, includesForMeta) {
   const projectEntries = [];
   for (let i = 0; i < projectionState.aliases.length; i++) {
@@ -1201,20 +1209,25 @@ function buildProjectionItems(projectionState, includesForMeta) {
         alias,
         expr: { kind: "includeRef", alias }
       });
-    } else if (isExpressionBuilder5(column)) {
-      projectEntries.push({
-        alias,
-        expr: column.expr
-      });
     } else {
-      const expr = column.toExpr();
-      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;
@@ -1720,4 +1733,4 @@ export {
   OrmModelBuilderImpl,
   orm
 };
-//# sourceMappingURL=chunk-C4EECZ4E.js.map
+//# sourceMappingURL=chunk-3DNKIXXB.js.map