@prisma/client-engine-runtime 6.7.0-dev.4 → 6.7.0-dev.40

package/dist/index.mjs

@@ -1,3 +1,30 @@
+// src/interpreter/QueryInterpreter.ts
+import { SpanKind } from "@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
 import { isDriverAdapterError } from "@prisma/driver-adapter-utils";
 var UserFacingError = class extends Error {
@@ -70,10 +97,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) {
@@ -128,10 +153,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) {
@@ -145,6 +168,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
 import cuid1 from "@bugsnag/cuid";
 import { createId as cuid2 } from "@paralleldrive/cuid2";
@@ -159,6 +276,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
@@ -221,6 +339,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) {
@@ -230,46 +364,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;
@@ -298,6 +435,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");
     }
@@ -356,9 +516,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(".");
@@ -380,15 +543,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(
@@ -432,14 +608,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": {
@@ -499,24 +675,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: 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) {
@@ -561,6 +751,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;
@@ -649,11 +841,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(),
@@ -687,12 +888,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);
@@ -783,5 +988,6 @@ export {
   TransactionManagerError,
   UserFacingError,
   isPrismaValueGenerator,
-  isPrismaValuePlaceholder
+  isPrismaValuePlaceholder,
+  noopTracingHelper
 };

package/dist/interpreter/DataMapper.d.ts

@@ -0,0 +1,3 @@
+import { ResultNode } from '../QueryPlan';
+import { Value } from './scope';
+export declare function applyDataMap(data: Value, structure: ResultNode): Value;

package/dist/interpreter/QueryInterpreter.d.ts

@@ -1,7 +1,9 @@
-import { SqlQueryable } from '@prisma/driver-adapter-utils';
+import { SqlQueryable, SqlResultSet } from '@prisma/driver-adapter-utils';
 import { QueryEvent } from '../events';
 import { QueryPlanNode } from '../QueryPlan';
+import { type TracingHelper } from '../tracing';
 import { type TransactionManager } from '../transactionManager/TransactionManager';
+import { Value } from './scope';
 export type QueryInterpreterTransactionManager = {
     enabled: true;
     manager: TransactionManager;
@@ -12,10 +14,18 @@ export type QueryInterpreterOptions = {
     transactionManager: QueryInterpreterTransactionManager;
     placeholderValues: Record<string, unknown>;
     onQuery?: (event: QueryEvent) => void;
+    tracingHelper: TracingHelper;
+    serializer: (results: SqlResultSet) => Value;
 };
 export declare class QueryInterpreter {
     #private;
-    constructor({ transactionManager, placeholderValues, onQuery }: QueryInterpreterOptions);
+    constructor({ transactionManager, placeholderValues, onQuery, tracingHelper, serializer }: QueryInterpreterOptions);
+    static forSql(options: {
+        transactionManager: QueryInterpreterTransactionManager;
+        placeholderValues: Record<string, unknown>;
+        onQuery?: (event: QueryEvent) => void;
+        tracingHelper: TracingHelper;
+    }): QueryInterpreter;
     run(queryPlan: QueryPlanNode, queryable: SqlQueryable): Promise<unknown>;
     private interpretNode;
 }

package/dist/interpreter/serializeSql.d.ts

@@ -0,0 +1,2 @@
+import type { SqlResultSet } from '@prisma/driver-adapter-utils';
+export declare function serializeSql(resultSet: SqlResultSet): Record<string, unknown>[];

package/dist/tracing.d.ts

@@ -0,0 +1,11 @@
+import type { Context, Span, SpanOptions } from '@opentelemetry/api';
+import type { Provider } from '@prisma/driver-adapter-utils';
+export type SpanCallback<R> = (span?: Span, context?: Context) => R;
+export type ExtendedSpanOptions = SpanOptions & {
+    name: string;
+};
+export interface TracingHelper {
+    runInChildSpan<R>(nameOrOptions: string | ExtendedSpanOptions, callback: SpanCallback<R>): R;
+}
+export declare const noopTracingHelper: TracingHelper;
+export declare function providerToOtelSystem(provider: Provider): string;

package/dist/transactionManager/TransactionManager.d.ts

@@ -1,13 +1,17 @@
 import { SqlDriverAdapter, Transaction } from '@prisma/driver-adapter-utils';
+import { TracingHelper } from '../tracing';
 import { Options, TransactionInfo } from './Transaction';
 export declare class TransactionManager {
+    #private;
     private transactions;
     private closedTransactions;
     private readonly driverAdapter;
     private readonly transactionOptions;
-    constructor({ driverAdapter, transactionOptions }: {
+    private readonly tracingHelper;
+    constructor({ driverAdapter, transactionOptions, tracingHelper, }: {
         driverAdapter: SqlDriverAdapter;
         transactionOptions: Options;
+        tracingHelper: TracingHelper;
     });
     startTransaction(options?: Options): Promise<TransactionInfo>;
     commitTransaction(transactionId: string): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/client-engine-runtime",
-  "version": "6.7.0-dev.4",
+  "version": "6.7.0-dev.40",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -25,12 +25,13 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@bugsnag/cuid": "3.2.1",
+    "@opentelemetry/api": "1.9.0",
     "@paralleldrive/cuid2": "2.2.2",
     "nanoid": "5.1.5",
     "ulid": "3.0.0",
     "uuid": "11.1.0",
-    "@prisma/debug": "6.7.0-dev.4",
-    "@prisma/driver-adapter-utils": "6.7.0-dev.4"
+    "@prisma/debug": "6.7.0-dev.40",
+    "@prisma/driver-adapter-utils": "6.7.0-dev.40"
   },
   "devDependencies": {
     "@types/jest": "29.5.14",

package/dist/interpreter/serialize.d.ts

@@ -1,2 +0,0 @@
-import type { SqlResultSet } from '@prisma/driver-adapter-utils';
-export declare function serialize(resultSet: SqlResultSet): Record<string, unknown>[];