@prisma/client-engine-runtime 6.7.0-dev.5 → 6.7.0-dev.50

package/dist/index.js

@@ -35,10 +35,38 @@ __export(index_exports, {
   TransactionManagerError: () => TransactionManagerError,
   UserFacingError: () => UserFacingError,
   isPrismaValueGenerator: () => isPrismaValueGenerator,
-  isPrismaValuePlaceholder: () => isPrismaValuePlaceholder
+  isPrismaValuePlaceholder: () => isPrismaValuePlaceholder,
+  noopTracingHelper: () => noopTracingHelper
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/interpreter/QueryInterpreter.ts
+var import_api = require("@opentelemetry/api");
+
+// src/utils.ts
+function assertNever(_, message) {
+  throw new Error(message);
+}
+
+// src/tracing.ts
+var noopTracingHelper = {
+  runInChildSpan(_, callback) {
+    return callback();
+  }
+};
+function providerToOtelSystem(provider) {
+  switch (provider) {
+    case "postgres":
+      return "postgresql";
+    case "mysql":
+      return "mysql";
+    case "sqlite":
+      return "sqlite";
+    default:
+      assertNever(provider, `Unknown provider: ${provider}`);
+  }
+}
+
 // src/UserFacingError.ts
 var import_driver_adapter_utils = require("@prisma/driver-adapter-utils");
 var UserFacingError = class extends Error {
@@ -111,10 +139,8 @@ function getErrorCode(err) {
     case "sqlite":
     case "mysql":
       return;
-    default: {
-      const cause = err.cause;
-      throw new Error(`Unknown error: ${cause}`);
-    }
+    default:
+      assertNever(err.cause, `Unknown error: ${err.cause}`);
   }
 }
 function renderErrorMessage(err) {
@@ -169,10 +195,8 @@ function renderErrorMessage(err) {
     case "postgres":
     case "mysql":
       return;
-    default: {
-      const cause = err.cause;
-      throw new Error(`Unknown error: ${cause}`);
-    }
+    default:
+      assertNever(err.cause, `Unknown error: ${err.cause}`);
   }
 }
 function renderConstraint(constraint) {
@@ -186,6 +210,100 @@ function renderConstraint(constraint) {
   return "(not available)";
 }
 
+// src/interpreter/DataMapper.ts
+function applyDataMap(data, structure) {
+  switch (structure.type) {
+    case "Object":
+      return mapArrayOrObject(data, structure.fields);
+    case "Value":
+      return mapValue(data, structure.resultType);
+    default:
+      assertNever(structure, `Invalid data mapping type: '${structure.type}'`);
+  }
+}
+function mapArrayOrObject(data, fields) {
+  if (data === null) return null;
+  if (Array.isArray(data)) {
+    const rows = data;
+    return rows.map((row) => mapObject(row, fields));
+  }
+  if (typeof data === "object") {
+    const row = data;
+    return mapObject(row, fields);
+  }
+  throw new Error(`DataMapper: Expected an array or an object, got: ${typeof data}`);
+}
+function mapObject(data, fields) {
+  if (typeof data !== "object") {
+    throw new Error(`DataMapper: Expected an object, but got '${typeof data}'`);
+  }
+  const result = {};
+  for (const [name, node] of Object.entries(fields)) {
+    switch (node.type) {
+      case "Object":
+        if (Object.hasOwn(data, name)) {
+          result[name] = mapArrayOrObject(data[name], node.fields);
+        } else {
+          throw new Error(
+            `DataMapper: Missing data field (Object): '${name}'; node: ${JSON.stringify(node)}; data: ${JSON.stringify(data)}`
+          );
+        }
+        break;
+      case "Value":
+        {
+          const dbName = node.dbName;
+          if (Object.hasOwn(data, dbName)) {
+            result[name] = mapValue(data[dbName], node.resultType);
+          } else {
+            throw new Error(
+              `DataMapper: Missing data field (Value): '${dbName}'; node: ${JSON.stringify(node)}; data: ${JSON.stringify(data)}`
+            );
+          }
+        }
+        break;
+      default:
+        assertNever(node, `DataMapper: Invalid data mapping node type: '${node.type}'`);
+    }
+  }
+  return result;
+}
+function mapValue(value, resultType) {
+  if (value === null) return null;
+  switch (resultType.type) {
+    case "Any":
+      return value;
+    case "String":
+      return typeof value === "string" ? value : `${value}`;
+    case "Int":
+      return typeof value === "number" ? value : parseInt(`${value}`, 10);
+    case "BigInt":
+      return typeof value === "bigint" ? value : BigInt(`${value}`);
+    case "Float":
+      return typeof value === "number" ? value : parseFloat(`${value}`);
+    case "Boolean":
+      return typeof value === "boolean" ? value : value !== "0";
+    case "Decimal":
+      return typeof value === "number" ? value : parseFloat(`${value}`);
+    case "Date":
+      return value instanceof Date ? value : /* @__PURE__ */ new Date(`${value}`);
+    case "Array": {
+      const values = value;
+      return values.map((v) => {
+        mapValue(v, resultType.inner);
+      });
+    }
+    case "Object":
+      return typeof value === "object" ? value : { value };
+    case "Bytes":
+      if (typeof value !== "string") {
+        throw new Error(`DataMapper: Bytes data is not a string, got: ${typeof value}`);
+      }
+      return value;
+    default:
+      assertNever(resultType, `DataMapper: Unknown result type: ${resultType.type}`);
+  }
+}
+
 // src/interpreter/generators.ts
 var import_cuid = __toESM(require("@bugsnag/cuid"));
 var import_cuid2 = require("@paralleldrive/cuid2");
@@ -200,6 +318,7 @@ var GeneratorRegistry = class {
     this.register("cuid", new CuidGenerator());
     this.register("ulid", new UlidGenerator());
     this.register("nanoid", new NanoIdGenerator());
+    this.register("product", new ProductGenerator());
   }
   /**
    * Returns a snapshot of the generator registry. It's 'frozen' in time at the moment of this
@@ -262,6 +381,22 @@ var NanoIdGenerator = class {
     }
   }
 };
+var ProductGenerator = class {
+  generate(lhs, rhs) {
+    if (lhs === void 0 || rhs === void 0) {
+      throw new Error("Invalid Product generator arguments");
+    }
+    if (Array.isArray(lhs) && Array.isArray(rhs)) {
+      return lhs.flatMap((l) => rhs.map((r) => [l, r]));
+    } else if (Array.isArray(lhs)) {
+      return lhs.map((l) => [l, rhs]);
+    } else if (Array.isArray(rhs)) {
+      return rhs.map((r) => [lhs, r]);
+    } else {
+      return [[lhs, rhs]];
+    }
+  }
+};
 
 // src/QueryPlan.ts
 function isPrismaValuePlaceholder(value) {
@@ -271,46 +406,49 @@ function isPrismaValueGenerator(value) {
   return typeof value === "object" && value !== null && value["prisma__type"] === "generatorCall";
 }
 
-// src/utils.ts
-function assertNever(_, message) {
-  throw new Error(message);
-}
-
 // src/interpreter/renderQuery.ts
 function renderQuery(dbQuery, scope, generators) {
   const queryType = dbQuery.type;
   switch (queryType) {
     case "rawSql":
-      return renderRawSql(dbQuery.sql, substituteParams(dbQuery.params, scope, generators));
+      return renderRawSql(dbQuery.sql, evaluateParams(dbQuery.params, scope, generators));
     case "templateSql":
       return renderTemplateSql(
         dbQuery.fragments,
         dbQuery.placeholderFormat,
-        substituteParams(dbQuery.params, scope, generators)
+        evaluateParams(dbQuery.params, scope, generators)
       );
     default:
       assertNever(queryType, `Invalid query type`);
   }
 }
-function substituteParams(params, scope, generators) {
-  return params.map((param) => {
-    if (isPrismaValueGenerator(param)) {
-      const { name, args } = param.prisma__value;
+function evaluateParams(params, scope, generators) {
+  return params.map((param) => evaluateParam(param, scope, generators));
+}
+function evaluateParam(param, scope, generators) {
+  let value = param;
+  while (doesRequireEvaluation(value)) {
+    if (isPrismaValuePlaceholder(value)) {
+      const found = scope[value.prisma__value.name];
+      if (found === void 0) {
+        throw new Error(`Missing value for query variable ${value.prisma__value.name}`);
+      }
+      value = found;
+    } else if (isPrismaValueGenerator(value)) {
+      const { name, args } = value.prisma__value;
       const generator = generators[name];
       if (!generator) {
         throw new Error(`Encountered an unknown generator '${name}'`);
       }
-      return generator.generate(...args);
-    }
-    if (!isPrismaValuePlaceholder(param)) {
-      return param;
-    }
-    const value = scope[param.prisma__value.name];
-    if (value === void 0) {
-      throw new Error(`Missing value for query variable ${param.prisma__value.name}`);
+      value = generator.generate(...args.map((arg) => evaluateParam(arg, scope, generators)));
+    } else {
+      assertNever(value, `Unexpected unevaluated value type: ${value}`);
     }
-    return value;
-  });
+  }
+  if (Array.isArray(value)) {
+    value = value.map((el) => evaluateParam(el, scope, generators));
+  }
+  return value;
 }
 function renderTemplateSql(fragments, placeholderFormat, params) {
   let paramIndex = 0;
@@ -339,6 +477,29 @@ function renderTemplateSql(fragments, placeholderFormat, params) {
         }).join(",");
         return `(${placeholders})`;
       }
+      case "parameterTupleList": {
+        if (paramIndex >= params.length) {
+          throw new Error(`Malformed query template. Fragments attempt to read over ${params.length} parameters.`);
+        }
+        const paramValue = params[paramIndex++];
+        if (!Array.isArray(paramValue)) {
+          throw new Error(`Malformed query template. Tuple list expected.`);
+        }
+        if (paramValue.length === 0) {
+          throw new Error(`Malformed query template. Tuple list cannot be empty.`);
+        }
+        const tupleList = paramValue.map((tuple) => {
+          if (!Array.isArray(tuple)) {
+            throw new Error(`Malformed query template. Tuple expected.`);
+          }
+          const elements = tuple.map((value) => {
+            flattenedParams.push(value);
+            return formatPlaceholder(placeholderFormat, placeholderNumber++);
+          }).join(",");
+          return `(${elements})`;
+        }).join(",");
+        return tupleList;
+      }
       default:
         assertNever(fragmentType, "Invalid fragment type");
     }
@@ -397,9 +558,12 @@ function placeholderTypeToArgType(type) {
   }
   return mappedType;
 }
+function doesRequireEvaluation(param) {
+  return isPrismaValuePlaceholder(param) || isPrismaValueGenerator(param);
+}
 
-// src/interpreter/serialize.ts
-function serialize(resultSet) {
+// src/interpreter/serializeSql.ts
+function serializeSql(resultSet) {
   return resultSet.rows.map(
     (row) => row.reduce((acc, value, index) => {
       const splitByDot = resultSet.columnNames[index].split(".");
@@ -421,15 +585,28 @@ function serialize(resultSet) {
 }
 
 // src/interpreter/QueryInterpreter.ts
-var QueryInterpreter = class {
+var QueryInterpreter = class _QueryInterpreter {
   #transactionManager;
   #placeholderValues;
   #onQuery;
   #generators = new GeneratorRegistry();
-  constructor({ transactionManager, placeholderValues, onQuery }) {
+  #tracingHelper;
+  #serializer;
+  constructor({ transactionManager, placeholderValues, onQuery, tracingHelper, serializer }) {
     this.#transactionManager = transactionManager;
     this.#placeholderValues = placeholderValues;
     this.#onQuery = onQuery;
+    this.#tracingHelper = tracingHelper;
+    this.#serializer = serializer;
+  }
+  static forSql(options) {
+    return new _QueryInterpreter({
+      transactionManager: options.transactionManager,
+      placeholderValues: options.placeholderValues,
+      onQuery: options.onQuery,
+      tracingHelper: options.tracingHelper,
+      serializer: serializeSql
+    });
   }
   async run(queryPlan, queryable) {
     return this.interpretNode(queryPlan, queryable, this.#placeholderValues, this.#generators.snapshot()).catch(
@@ -473,14 +650,14 @@ var QueryInterpreter = class {
       }
       case "execute": {
         const query = renderQuery(node.args, scope, generators);
-        return this.#withQueryEvent(query, async () => {
+        return this.#withQueryEvent(query, queryable, async () => {
           return await queryable.executeRaw(query);
         });
       }
       case "query": {
         const query = renderQuery(node.args, scope, generators);
-        return this.#withQueryEvent(query, async () => {
-          return serialize(await queryable.queryRaw(query));
+        return this.#withQueryEvent(query, queryable, async () => {
+          return this.#serializer(await queryable.queryRaw(query));
         });
       }
       case "reverse": {
@@ -530,7 +707,7 @@ var QueryInterpreter = class {
         }
         const transactionManager = this.#transactionManager.manager;
         const transactionInfo = await transactionManager.startTransaction();
-        const transaction = transactionManager.getTransaction(transactionInfo, "new");
+        const transaction = transactionManager.getTransaction(transactionInfo, "query");
         try {
           const value = await this.interpretNode(node.args, transaction, scope, generators);
           await transactionManager.commitTransaction(transactionInfo.id);
@@ -540,24 +717,38 @@ var QueryInterpreter = class {
           throw e;
         }
       }
-      default: {
-        node;
-        throw new Error(`Unexpected node type: ${node.type}`);
+      case "dataMap": {
+        const data = await this.interpretNode(node.args.expr, queryable, scope, generators);
+        return applyDataMap(data, node.args.structure);
       }
+      default:
+        assertNever(node, `Unexpected node type: ${node.type}`);
     }
   }
-  async #withQueryEvent(query, execute) {
-    const timestamp = /* @__PURE__ */ new Date();
-    const startInstant = performance.now();
-    const result = await execute();
-    const endInstant = performance.now();
-    this.#onQuery?.({
-      timestamp,
-      duration: endInstant - startInstant,
-      query: query.sql,
-      params: query.args
-    });
-    return result;
+  #withQueryEvent(query, queryable, execute) {
+    return this.#tracingHelper.runInChildSpan(
+      {
+        name: "db_query",
+        kind: import_api.SpanKind.CLIENT,
+        attributes: {
+          "db.query.text": query.sql,
+          "db.system.name": providerToOtelSystem(queryable.provider)
+        }
+      },
+      async () => {
+        const timestamp = /* @__PURE__ */ new Date();
+        const startInstant = performance.now();
+        const result = await execute();
+        const endInstant = performance.now();
+        this.#onQuery?.({
+          timestamp,
+          duration: endInstant - startInstant,
+          query: query.sql,
+          params: query.args
+        });
+        return result;
+      }
+    );
   }
 };
 function isEmpty(value) {
@@ -602,6 +793,8 @@ function attachChildrenToParent(parentRecord, children) {
 function filterChildRecords(records, parentRecord, joinExpr) {
   if (Array.isArray(records)) {
     return records.filter((record) => childRecordMatchesParent(asRecord(record), parentRecord, joinExpr));
+  } else if (records === null) {
+    return null;
   } else {
     const record = asRecord(records);
     return childRecordMatchesParent(record, parentRecord, joinExpr) ? record : null;
@@ -650,7 +843,7 @@ var TransactionClosedError = class extends TransactionManagerError {
 };
 var TransactionRolledBackError = class extends TransactionManagerError {
   constructor(operation) {
-    super(`Transaction already closed: A ${operation} cannot be executed on a committed transaction`);
+    super(`Transaction already closed: A ${operation} cannot be executed on a transaction that was rolled back`);
   }
 };
 var TransactionStartTimeoutError = class extends TransactionManagerError {
@@ -690,11 +883,20 @@ var TransactionManager = class {
   closedTransactions = [];
   driverAdapter;
   transactionOptions;
-  constructor({ driverAdapter, transactionOptions }) {
+  tracingHelper;
+  constructor({
+    driverAdapter,
+    transactionOptions,
+    tracingHelper
+  }) {
     this.driverAdapter = driverAdapter;
     this.transactionOptions = transactionOptions;
+    this.tracingHelper = tracingHelper;
   }
   async startTransaction(options) {
+    return await this.tracingHelper.runInChildSpan("start_transaction", () => this.#startTransactionImpl(options));
+  }
+  async #startTransactionImpl(options) {
     const validatedOptions = options !== void 0 ? this.validateOptions(options) : this.transactionOptions;
     const transaction = {
       id: await randomUUID(),
@@ -728,12 +930,16 @@ var TransactionManager = class {
     }
   }
   async commitTransaction(transactionId) {
-    const txw = this.getActiveTransaction(transactionId, "commit");
-    await this.closeTransaction(txw, "committed");
+    return await this.tracingHelper.runInChildSpan("commit_transaction", async () => {
+      const txw = this.getActiveTransaction(transactionId, "commit");
+      await this.closeTransaction(txw, "committed");
+    });
   }
   async rollbackTransaction(transactionId) {
-    const txw = this.getActiveTransaction(transactionId, "rollback");
-    await this.closeTransaction(txw, "rolled_back");
+    return await this.tracingHelper.runInChildSpan("rollback_transaction", async () => {
+      const txw = this.getActiveTransaction(transactionId, "rollback");
+      await this.closeTransaction(txw, "rolled_back");
+    });
   }
   getTransaction(txInfo, operation) {
     const tx = this.getActiveTransaction(txInfo.id, operation);
@@ -825,5 +1031,6 @@ var TransactionManager = class {
   TransactionManagerError,
   UserFacingError,
   isPrismaValueGenerator,
-  isPrismaValuePlaceholder
+  isPrismaValuePlaceholder,
+  noopTracingHelper
 });