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

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

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