@prisma/client-engine-runtime 6.7.0-dev.3 → 6.7.0-dev.30

package/dist/index.js

@@ -33,11 +33,277 @@ __export(index_exports, {
   QueryInterpreter: () => QueryInterpreter,
   TransactionManager: () => TransactionManager,
   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 {
+  name = "UserFacingError";
+  code;
+  meta;
+  constructor(message, code, meta) {
+    super(message);
+    this.code = code;
+    this.meta = meta;
+  }
+  toQueryResponseErrorObject() {
+    return {
+      error: this.message,
+      user_facing_error: {
+        is_panic: false,
+        message: this.message,
+        meta: this.meta,
+        error_code: this.code
+      }
+    };
+  }
+};
+function rethrowAsUserFacing(error) {
+  if (!(0, import_driver_adapter_utils.isDriverAdapterError)(error)) {
+    throw error;
+  }
+  const code = getErrorCode(error);
+  const message = renderErrorMessage(error);
+  if (!code || !message) {
+    throw error;
+  }
+  throw new UserFacingError(message, code, error);
+}
+function getErrorCode(err) {
+  switch (err.cause.kind) {
+    case "AuthenticationFailed":
+      return "P1000";
+    case "DatabaseDoesNotExist":
+      return "P1003";
+    case "SocketTimeout":
+      return "P1008";
+    case "DatabaseAlreadyExists":
+      return "P1009";
+    case "DatabaseAccessDenied":
+      return "P1010";
+    case "LengthMismatch":
+      return "P2000";
+    case "UniqueConstraintViolation":
+      return "P2002";
+    case "ForeignKeyConstraintViolation":
+      return "P2003";
+    case "UnsupportedNativeDataType":
+      return "P2010";
+    case "NullConstraintViolation":
+      return "P2011";
+    case "TableDoesNotExist":
+      return "P2021";
+    case "ColumnNotFound":
+      return "P2022";
+    case "InvalidIsolationLevel":
+      return "P2023";
+    case "TransactionWriteConflict":
+      return "P2034";
+    case "GenericJs":
+      return "P2036";
+    case "TooManyConnections":
+      return "P2037";
+    case "postgres":
+    case "sqlite":
+    case "mysql":
+      return;
+    default:
+      assertNever(err.cause, `Unknown error: ${err.cause}`);
+  }
+}
+function renderErrorMessage(err) {
+  switch (err.cause.kind) {
+    case "AuthenticationFailed": {
+      const user = err.cause.user ?? "(not available)";
+      return `Authentication failed against the database server, the provided database credentials for \`${user}\` are not valid`;
+    }
+    case "DatabaseDoesNotExist": {
+      const db = err.cause.db ?? "(not available)";
+      return `Database \`${db}\` does not exist on the database server`;
+    }
+    case "SocketTimeout":
+      return `Operation has timed out`;
+    case "DatabaseAlreadyExists": {
+      const db = err.cause.db ?? "(not available)";
+      return `Database \`${db}\` already exists on the database server`;
+    }
+    case "DatabaseAccessDenied": {
+      const db = err.cause.db ?? "(not available)";
+      return `User was denied access on the database \`${db}\``;
+    }
+    case "LengthMismatch": {
+      const column = err.cause.column ?? "(not available)";
+      return `The provided value for the column is too long for the column's type. Column: ${column}`;
+    }
+    case "UniqueConstraintViolation":
+      return `Unique constraint failed on the ${renderConstraint({ fields: err.cause.fields })}`;
+    case "ForeignKeyConstraintViolation":
+      return `Foreign key constraint violated on the ${renderConstraint(err.cause.constraint)}`;
+    case "UnsupportedNativeDataType":
+      return `Failed to deserialize column of type '${err.cause.type}'. If you're using $queryRaw and this column is explicitly marked as \`Unsupported\` in your Prisma schema, try casting this column to any supported Prisma type such as \`String\`.`;
+    case "NullConstraintViolation":
+      return `Null constraint violation on the ${renderConstraint({ fields: err.cause.fields })}`;
+    case "TableDoesNotExist": {
+      const table = err.cause.table ?? "(not available)";
+      return `The table \`${table}\` does not exist in the current database.`;
+    }
+    case "ColumnNotFound": {
+      const column = err.cause.column ?? "(not available)";
+      return `The column \`${column}\` does not exist in the current database.`;
+    }
+    case "InvalidIsolationLevel":
+      return `Invalid isolation level \`${err.cause.level}\``;
+    case "TransactionWriteConflict":
+      return `Transaction failed due to a write conflict or a deadlock. Please retry your transaction`;
+    case "GenericJs":
+      return `Error in external connector (id ${err.cause.id})`;
+    case "TooManyConnections":
+      return `Too many database connections opened: ${err.cause.cause}`;
+    case "sqlite":
+    case "postgres":
+    case "mysql":
+      return;
+    default:
+      assertNever(err.cause, `Unknown error: ${err.cause}`);
+  }
+}
+function renderConstraint(constraint) {
+  if (constraint && "fields" in constraint) {
+    return `fields: (${constraint.fields.map((field) => `\`${field}\``).join(", ")})`;
+  } else if (constraint && "index" in constraint) {
+    return `constraint: \`${constraint.index}\``;
+  } else if (constraint && "foreignKey" in constraint) {
+    return `foreign key`;
+  }
+  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");
@@ -52,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
@@ -114,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) {
@@ -123,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;
@@ -191,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");
     }
@@ -249,6 +558,9 @@ function placeholderTypeToArgType(type) {
   }
   return mappedType;
 }
+function doesRequireEvaluation(param) {
+  return isPrismaValuePlaceholder(param) || isPrismaValueGenerator(param);
+}
 
 // src/interpreter/serialize.ts
 function serialize(resultSet) {
@@ -278,13 +590,17 @@ var QueryInterpreter = class {
   #placeholderValues;
   #onQuery;
   #generators = new GeneratorRegistry();
-  constructor({ transactionManager, placeholderValues, onQuery }) {
+  #tracingHelper;
+  constructor({ transactionManager, placeholderValues, onQuery, tracingHelper }) {
     this.#transactionManager = transactionManager;
     this.#placeholderValues = placeholderValues;
     this.#onQuery = onQuery;
+    this.#tracingHelper = tracingHelper;
   }
   async run(queryPlan, queryable) {
-    return this.interpretNode(queryPlan, queryable, this.#placeholderValues, this.#generators.snapshot());
+    return this.interpretNode(queryPlan, queryable, this.#placeholderValues, this.#generators.snapshot()).catch(
+      (e) => rethrowAsUserFacing(e)
+    );
   }
   async interpretNode(node, queryable, scope, generators) {
     switch (node.type) {
@@ -323,13 +639,13 @@ 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 this.#withQueryEvent(query, queryable, async () => {
           return serialize(await queryable.queryRaw(query));
         });
       }
@@ -390,24 +706,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) {
@@ -452,6 +782,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;
@@ -540,11 +872,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(),
@@ -578,12 +919,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);
@@ -673,6 +1018,8 @@ var TransactionManager = class {
   QueryInterpreter,
   TransactionManager,
   TransactionManagerError,
+  UserFacingError,
   isPrismaValueGenerator,
-  isPrismaValuePlaceholder
+  isPrismaValuePlaceholder,
+  noopTracingHelper
 });