@prisma/client-engine-runtime 6.4.0-dev.48 → 6.4.0-dev.50

package/dist/index.mjs

@@ -0,0 +1,652 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/QueryPlan.ts
+function isPrismaValuePlaceholder(value) {
+  return typeof value === "object" && value !== null && value["prisma__type"] === "param";
+}
+
+// src/interpreter/renderQueryTemplate.ts
+var BEGIN_REPEAT = "/* prisma-comma-repeatable-start */";
+var END_REPEAT = "/* prisma-comma-repeatable-end */";
+function renderQueryTemplate({
+  query,
+  params
+}) {
+  if (!query.includes(BEGIN_REPEAT)) {
+    return { query, params };
+  }
+  const flattenedParams = [];
+  let lastParamId = 1;
+  let result = "";
+  let templatePos = 0;
+  let state = 0 /* Normal */;
+  let stateBeforeQuote = 0 /* Normal */;
+  while (templatePos < query.length) {
+    const nextChar = query[templatePos];
+    if (state === 1 /* Quoted */ && nextChar !== '"') {
+      result += nextChar;
+      templatePos++;
+      continue;
+    }
+    if (nextChar === '"') {
+      if (state === 1 /* Quoted */) {
+        state = stateBeforeQuote;
+      } else {
+        stateBeforeQuote = state;
+        state = 1 /* Quoted */;
+      }
+      result += nextChar;
+      templatePos++;
+      continue;
+    }
+    if (query.slice(templatePos, templatePos + BEGIN_REPEAT.length) === BEGIN_REPEAT) {
+      if (state === 2 /* Repeating */) {
+        throw new Error("Nested repetition is not allowed");
+      }
+      state = 2 /* Repeating */;
+      templatePos += BEGIN_REPEAT.length;
+      result += "(";
+      continue;
+    }
+    if (query.slice(templatePos, templatePos + END_REPEAT.length) === END_REPEAT) {
+      if (state === 0 /* Normal */) {
+        throw new Error("Unmatched repetition end");
+      }
+      state = 0 /* Normal */;
+      templatePos += END_REPEAT.length;
+      result += ")";
+      continue;
+    }
+    if (nextChar === "$") {
+      const paramMatch = query.slice(templatePos + 1).match(/^\d+/);
+      if (!paramMatch) {
+        result += "$";
+        templatePos++;
+        continue;
+      }
+      templatePos += paramMatch[0].length + 1;
+      const originalParamIdx = parseInt(paramMatch[0]);
+      const paramValue = params[originalParamIdx - 1];
+      switch (state) {
+        case 0 /* Normal */: {
+          flattenedParams.push(paramValue);
+          result += `$${lastParamId++}`;
+          break;
+        }
+        case 2 /* Repeating */: {
+          const paramArray = Array.isArray(paramValue) ? paramValue : [paramValue];
+          if (paramArray.length === 0) {
+            result += "NULL";
+            break;
+          }
+          paramArray.forEach((value, idx) => {
+            flattenedParams.push(value);
+            result += `$${lastParamId++}`;
+            if (idx !== paramArray.length - 1) {
+              result += ", ";
+            }
+          });
+          break;
+        }
+        default: {
+          throw new Error(`Unexpected state: ${state}`);
+        }
+      }
+      continue;
+    }
+    result += nextChar;
+    templatePos++;
+  }
+  return {
+    query: result,
+    params: flattenedParams
+  };
+}
+
+// src/interpreter/renderQuery.ts
+function renderQuery({ query, params }, scope) {
+  const substitutedParams = params.map((param) => {
+    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}`);
+    }
+    return value;
+  });
+  const { query: renderedQuery, params: expandedParams } = renderQueryTemplate({ query, params: substitutedParams });
+  const argTypes = expandedParams.map((param) => toArgType(param));
+  return {
+    sql: renderedQuery,
+    args: expandedParams,
+    argTypes
+  };
+}
+function toArgType(value) {
+  if (value === null) {
+    return "Int32";
+  }
+  if (typeof value === "string") {
+    return "Text";
+  }
+  if (typeof value === "number") {
+    return "Numeric";
+  }
+  if (typeof value === "boolean") {
+    return "Boolean";
+  }
+  if (Array.isArray(value)) {
+    return "Array";
+  }
+  if (isPrismaValuePlaceholder(value)) {
+    return placeholderTypeToArgType(value.prisma__value.type);
+  }
+  return "Json";
+}
+function placeholderTypeToArgType(type) {
+  const typeMap = {
+    Any: "Json",
+    String: "Text",
+    Int: "Int32",
+    BigInt: "Int64",
+    Float: "Double",
+    Boolean: "Boolean",
+    Decimal: "Numeric",
+    Date: "DateTime",
+    Object: "Json",
+    Bytes: "Bytes",
+    Array: "Array"
+  };
+  const mappedType = typeMap[type];
+  if (!mappedType) {
+    throw new Error(`Unknown placeholder type: ${type}`);
+  }
+  return mappedType;
+}
+
+// src/interpreter/serialize.ts
+function serialize(resultSet) {
+  return resultSet.rows.map(
+    (row) => row.reduce((acc, value, index) => {
+      const splitByDot = resultSet.columnNames[index].split(".");
+      let nested = acc;
+      for (let i = 0; i < splitByDot.length; i++) {
+        const key = splitByDot[i];
+        if (i === splitByDot.length - 1) {
+          nested[key] = value;
+        } else {
+          if (nested[key] === void 0) {
+            nested[key] = {};
+          }
+          nested = nested[key];
+        }
+      }
+      return acc;
+    }, {})
+  );
+}
+
+// src/interpreter/QueryInterpreter.ts
+var _queryable, _placeholderValues, _onQuery, _QueryInterpreter_instances, withQueryEvent_fn;
+var QueryInterpreter = class {
+  constructor({ queryable, placeholderValues, onQuery }) {
+    __privateAdd(this, _QueryInterpreter_instances);
+    __privateAdd(this, _queryable);
+    __privateAdd(this, _placeholderValues);
+    __privateAdd(this, _onQuery);
+    __privateSet(this, _queryable, queryable);
+    __privateSet(this, _placeholderValues, placeholderValues);
+    __privateSet(this, _onQuery, onQuery);
+  }
+  async run(queryPlan) {
+    return this.interpretNode(queryPlan, __privateGet(this, _placeholderValues));
+  }
+  async interpretNode(node, scope) {
+    switch (node.type) {
+      case "seq": {
+        const results = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope)));
+        return results[results.length - 1];
+      }
+      case "get": {
+        return scope[node.args.name];
+      }
+      case "let": {
+        const nestedScope = Object.create(scope);
+        await Promise.all(
+          node.args.bindings.map(async (binding) => {
+            nestedScope[binding.name] = await this.interpretNode(binding.expr, scope);
+          })
+        );
+        return this.interpretNode(node.args.expr, nestedScope);
+      }
+      case "getFirstNonEmpty": {
+        for (const name of node.args.names) {
+          const value = scope[name];
+          if (!isEmpty(value)) {
+            return value;
+          }
+        }
+        return [];
+      }
+      case "concat": {
+        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope)));
+        return parts.reduce((acc, part) => acc.concat(asList(part)), []);
+      }
+      case "sum": {
+        const parts = await Promise.all(node.args.map((arg) => this.interpretNode(arg, scope)));
+        return parts.reduce((acc, part) => asNumber(acc) + asNumber(part));
+      }
+      case "execute": {
+        const query = renderQuery(node.args, scope);
+        return __privateMethod(this, _QueryInterpreter_instances, withQueryEvent_fn).call(this, query, async () => {
+          const result = await __privateGet(this, _queryable).executeRaw(query);
+          if (result.ok) {
+            return result.value;
+          } else {
+            throw result.error;
+          }
+        });
+      }
+      case "query": {
+        const query = renderQuery(node.args, scope);
+        return __privateMethod(this, _QueryInterpreter_instances, withQueryEvent_fn).call(this, query, async () => {
+          const result = await __privateGet(this, _queryable).queryRaw(query);
+          if (result.ok) {
+            return serialize(result.value);
+          } else {
+            throw result.error;
+          }
+        });
+      }
+      case "reverse": {
+        const value = await this.interpretNode(node.args, scope);
+        return Array.isArray(value) ? value.reverse() : value;
+      }
+      case "unique": {
+        const value = await this.interpretNode(node.args, scope);
+        if (!Array.isArray(value)) {
+          return value;
+        }
+        if (value.length > 1) {
+          throw new Error(`Expected zero or one element, got ${value.length}`);
+        }
+        return value[0] ?? null;
+      }
+      case "required": {
+        const value = await this.interpretNode(node.args, scope);
+        if (isEmpty(value)) {
+          throw new Error("Required value is empty");
+        }
+        return value;
+      }
+      case "mapField": {
+        const value = await this.interpretNode(node.args.records, scope);
+        return mapField(value, node.args.field);
+      }
+      case "join": {
+        const parent = await this.interpretNode(node.args.parent, scope);
+        const children = await Promise.all(
+          node.args.children.map(async (joinExpr) => ({
+            joinExpr,
+            childRecords: await this.interpretNode(joinExpr.child, scope)
+          }))
+        );
+        if (Array.isArray(parent)) {
+          for (const record of parent) {
+            attachChildrenToParent(asRecord(record), children);
+          }
+          return parent;
+        }
+        return attachChildrenToParent(asRecord(parent), children);
+      }
+      default: {
+        node;
+        throw new Error(`Unexpected node type: ${node.type}`);
+      }
+    }
+  }
+};
+_queryable = new WeakMap();
+_placeholderValues = new WeakMap();
+_onQuery = new WeakMap();
+_QueryInterpreter_instances = new WeakSet();
+withQueryEvent_fn = async function(query, execute) {
+  var _a;
+  const timestamp = /* @__PURE__ */ new Date();
+  const startInstant = performance.now();
+  const result = await execute();
+  const endInstant = performance.now();
+  (_a = __privateGet(this, _onQuery)) == null ? void 0 : _a.call(this, {
+    timestamp,
+    duration: endInstant - startInstant,
+    query: query.sql,
+    params: query.args
+  });
+  return result;
+};
+function isEmpty(value) {
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+  return value == null;
+}
+function asList(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function asNumber(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return Number(value);
+  }
+  throw new Error(`Expected number, got ${typeof value}`);
+}
+function asRecord(value) {
+  if (typeof value === "object" && value !== null) {
+    return value;
+  }
+  throw new Error(`Expected object, got ${typeof value}`);
+}
+function mapField(value, field) {
+  if (Array.isArray(value)) {
+    return value.map((element) => mapField(element, field));
+  }
+  if (typeof value === "object" && value !== null) {
+    return value[field] ?? null;
+  }
+  return value;
+}
+function attachChildrenToParent(parentRecord, children) {
+  for (const { joinExpr, childRecords } of children) {
+    parentRecord[joinExpr.parentField] = filterChildRecords(childRecords, parentRecord, joinExpr);
+  }
+  return parentRecord;
+}
+function filterChildRecords(records, parentRecord, joinExpr) {
+  if (Array.isArray(records)) {
+    return records.filter((record) => childRecordMatchesParent(asRecord(record), parentRecord, joinExpr));
+  } else {
+    const record = asRecord(records);
+    return childRecordMatchesParent(record, parentRecord, joinExpr) ? record : null;
+  }
+}
+function childRecordMatchesParent(childRecord, parentRecord, joinExpr) {
+  for (const [parentField, childField] of joinExpr.on) {
+    if (parentRecord[parentField] !== childRecord[childField]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/transactionManager/Transaction.ts
+var IsolationLevel = /* @__PURE__ */ ((IsolationLevel2) => {
+  IsolationLevel2["ReadUncommitted"] = "ReadUncommitted";
+  IsolationLevel2["ReadCommitted"] = "ReadCommitted";
+  IsolationLevel2["RepeatableRead"] = "RepeatableRead";
+  IsolationLevel2["Snapshot"] = "Snapshot";
+  IsolationLevel2["Serializable"] = "Serializable";
+  return IsolationLevel2;
+})(IsolationLevel || {});
+
+// src/transactionManager/TransactionManager.ts
+import crypto from "node:crypto";
+import Debug from "@prisma/debug";
+
+// src/utils.ts
+function assertNever(_, message) {
+  throw new Error(message);
+}
+
+// src/transactionManager/TransactionManagerErrors.ts
+var TransactionManagerError = class extends Error {
+  constructor(message, meta) {
+    super("Transaction API error: " + message);
+    this.meta = meta;
+    this.code = "P2028";
+  }
+};
+var TransactionDriverAdapterError = class extends TransactionManagerError {
+  constructor(message, errorParams) {
+    super(`Error from Driver Adapter: ${message}`, { ...errorParams.driverAdapterError });
+  }
+};
+var TransactionNotFoundError = class extends TransactionManagerError {
+  constructor() {
+    super(
+      "Transaction not found. Transaction ID is invalid, refers to an old closed transaction Prisma doesn't have information about anymore, or was obtained before disconnecting."
+    );
+  }
+};
+var TransactionClosedError = class extends TransactionManagerError {
+  constructor(operation) {
+    super(`Transaction already closed: A ${operation} cannot be executed on a committed transaction`);
+  }
+};
+var TransactionRolledBackError = class extends TransactionManagerError {
+  constructor(operation) {
+    super(`Transaction already closed: A ${operation} cannot be executed on a committed transaction`);
+  }
+};
+var TransactionStartTimoutError = class extends TransactionManagerError {
+  constructor() {
+    super("Unable to start a transaction in the given time.");
+  }
+};
+var TransactionExecutionTimeoutError = class extends TransactionManagerError {
+  constructor(operation, { timeout, timeTaken }) {
+    super(
+      `A ${operation} cannot be executed on an expired transaction. The timeout for this transaction was ${timeout} ms, however ${timeTaken} ms passed since the start of the transaction. Consider increasing the interactive transaction timeout or doing less work in the transaction`,
+      { operation, timeout, timeTaken }
+    );
+  }
+};
+var TransactionInternalConsistencyError = class extends TransactionManagerError {
+  constructor(message) {
+    super(`Internal Consistency Error: ${message}`);
+  }
+};
+var InvalidTransactionIsolationLevelError = class extends TransactionManagerError {
+  constructor(isolationLevel) {
+    super(`Invalid isolation level: ${isolationLevel}`, { isolationLevel });
+  }
+};
+
+// src/transactionManager/TransactionManager.ts
+var MAX_CLOSED_TRANSACTIONS = 100;
+var isolationLevelMap = {
+  ReadUncommitted: "READ UNCOMMITTED",
+  ReadCommitted: "READ COMMITTED",
+  RepeatableRead: "REPEATABLE READ",
+  Snapshot: "SNAPSHOT",
+  Serializable: "SERIALIZABLE"
+};
+var debug = Debug("prisma:client:transactionManager");
+var COMMIT_QUERY = () => ({ sql: "COMMIT", args: [], argTypes: [] });
+var ROLLBACK_QUERY = () => ({ sql: "ROLLBACK", args: [], argTypes: [] });
+var ISOLATION_LEVEL_QUERY = (isolationLevel) => ({
+  sql: "SET TRANSACTION ISOLATION LEVEL " + isolationLevelMap[isolationLevel],
+  args: [],
+  argTypes: []
+});
+var TransactionManager = class {
+  constructor({ driverAdapter }) {
+    // The map of active transactions.
+    this.transactions = /* @__PURE__ */ new Map();
+    // List of last closed transactions. Max MAX_CLOSED_TRANSACTIONS entries.
+    // Used to provide better error messages than a generic "transaction not found".
+    this.closedTransactions = [];
+    this.driverAdapter = driverAdapter;
+  }
+  async startTransaction(options) {
+    const validatedOptions = this.validateOptions(options);
+    const transaction = {
+      id: crypto.randomUUID(),
+      status: "waiting",
+      timer: void 0,
+      timeout: validatedOptions.timeout,
+      startedAt: Date.now(),
+      transaction: void 0
+    };
+    this.transactions.set(transaction.id, transaction);
+    transaction.timer = this.startTransactionTimeout(transaction.id, validatedOptions.maxWait);
+    const txContext = await this.driverAdapter.transactionContext();
+    if (!txContext.ok)
+      throw new TransactionDriverAdapterError("Failed to start transaction.", {
+        driverAdapterError: txContext.error
+      });
+    if (this.requiresSettingIsolationLevelFirst() && validatedOptions.isolationLevel) {
+      await txContext.value.executeRaw(ISOLATION_LEVEL_QUERY(validatedOptions.isolationLevel));
+    }
+    const startedTransaction = await txContext.value.startTransaction();
+    if (!startedTransaction.ok)
+      throw new TransactionDriverAdapterError("Failed to start transaction.", {
+        driverAdapterError: startedTransaction.error
+      });
+    if (!startedTransaction.value.options.usePhantomQuery) {
+      await startedTransaction.value.executeRaw({ sql: "BEGIN", args: [], argTypes: [] });
+      if (!this.requiresSettingIsolationLevelFirst() && validatedOptions.isolationLevel) {
+        await txContext.value.executeRaw(ISOLATION_LEVEL_QUERY(validatedOptions.isolationLevel));
+      }
+    }
+    switch (transaction.status) {
+      case "waiting":
+        transaction.transaction = startedTransaction.value;
+        clearTimeout(transaction.timer);
+        transaction.timer = void 0;
+        transaction.status = "running";
+        transaction.timer = this.startTransactionTimeout(transaction.id, validatedOptions.timeout);
+        return { id: transaction.id };
+      case "timed_out":
+        throw new TransactionStartTimoutError();
+      case "running":
+      case "committed":
+      case "rolled_back":
+        throw new TransactionInternalConsistencyError(
+          `Transaction in invalid state ${transaction.status} although it just finished startup.`
+        );
+      default:
+        assertNever(transaction.status, "Unknown transaction status.");
+    }
+  }
+  async commitTransaction(transactionId) {
+    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");
+  }
+  getTransaction(txInfo, operation) {
+    const tx = this.getActiveTransaction(txInfo.id, operation);
+    if (!tx.transaction) throw new TransactionNotFoundError();
+    return tx.transaction;
+  }
+  getActiveTransaction(transactionId, operation) {
+    const transaction = this.transactions.get(transactionId);
+    if (!transaction) {
+      const closedTransaction = this.closedTransactions.find((tx) => tx.id === transactionId);
+      if (closedTransaction) {
+        debug("Transaction already closed.", { transactionId, status: closedTransaction.status });
+        switch (closedTransaction.status) {
+          case "waiting":
+          case "running":
+            throw new TransactionInternalConsistencyError("Active transaction found in closed transactions list.");
+          case "committed":
+            throw new TransactionClosedError(operation);
+          case "rolled_back":
+            throw new TransactionRolledBackError(operation);
+          case "timed_out":
+            throw new TransactionExecutionTimeoutError(operation, {
+              timeout: closedTransaction.timeout,
+              timeTaken: Date.now() - closedTransaction.startedAt
+            });
+        }
+      } else {
+        debug(`Transaction not found.`, transactionId);
+        throw new TransactionNotFoundError();
+      }
+    }
+    if (["committed", "rolled_back", "timed_out"].includes(transaction.status)) {
+      throw new TransactionInternalConsistencyError("Closed transaction found in active transactions map.");
+    }
+    return transaction;
+  }
+  async cancelAllTransactions() {
+    await Promise.allSettled([...this.transactions.values()].map((tx) => this.closeTransaction(tx, "rolled_back")));
+  }
+  startTransactionTimeout(transactionId, timeout) {
+    const timeoutStartedAt = Date.now();
+    return setTimeout(async () => {
+      debug("Transaction timed out.", { transactionId, timeoutStartedAt, timeout });
+      const tx = this.transactions.get(transactionId);
+      if (tx && ["running", "waiting"].includes(tx.status)) {
+        await this.closeTransaction(tx, "timed_out");
+      } else {
+        debug("Transaction already committed or rolled back when timeout happened.", transactionId);
+      }
+    }, timeout);
+  }
+  async closeTransaction(tx, status) {
+    debug("Closing transaction.", { transactionId: tx.id, status });
+    tx.status = status;
+    if (tx.transaction && status === "committed") {
+      const result = await tx.transaction.commit();
+      if (!result.ok)
+        throw new TransactionDriverAdapterError("Failed to commit transaction.", {
+          driverAdapterError: result.error
+        });
+      if (!tx.transaction.options.usePhantomQuery) {
+        await tx.transaction.executeRaw(COMMIT_QUERY());
+      }
+    } else if (tx.transaction) {
+      const result = await tx.transaction.rollback();
+      if (!result.ok)
+        throw new TransactionDriverAdapterError("Failed to rollback transaction.", {
+          driverAdapterError: result.error
+        });
+      if (!tx.transaction.options.usePhantomQuery) {
+        await tx.transaction.executeRaw(ROLLBACK_QUERY());
+      }
+    }
+    clearTimeout(tx.timer);
+    tx.timer = void 0;
+    this.transactions.delete(tx.id);
+    this.closedTransactions.push(tx);
+    if (this.closedTransactions.length > MAX_CLOSED_TRANSACTIONS) {
+      this.closedTransactions.shift();
+    }
+  }
+  validateOptions(options) {
+    if (!options.timeout) throw new TransactionManagerError("timeout is required");
+    if (!options.maxWait) throw new TransactionManagerError("maxWait is required");
+    if (options.isolationLevel === "Snapshot" /* Snapshot */)
+      throw new InvalidTransactionIsolationLevelError(options.isolationLevel);
+    if (this.driverAdapter.provider === "sqlite" && options.isolationLevel && options.isolationLevel !== "Serializable" /* Serializable */)
+      throw new InvalidTransactionIsolationLevelError(options.isolationLevel);
+    return {
+      ...options,
+      timeout: options.timeout,
+      maxWait: options.maxWait
+    };
+  }
+  requiresSettingIsolationLevelFirst() {
+    return this.driverAdapter.provider === "mysql";
+  }
+};
+export {
+  IsolationLevel,
+  QueryInterpreter,
+  TransactionManager,
+  TransactionManagerError,
+  isPrismaValuePlaceholder
+};

package/dist/interpreter/QueryInterpreter.d.ts

@@ -0,0 +1,14 @@
+import { Queryable } from '@prisma/driver-adapter-utils';
+import { QueryEvent } from '../events';
+import { QueryPlanNode } from '../QueryPlan';
+export type QueryInterpreterOptions = {
+    queryable: Queryable;
+    placeholderValues: Record<string, unknown>;
+    onQuery?: (event: QueryEvent) => void;
+};
+export declare class QueryInterpreter {
+    #private;
+    constructor({ queryable, placeholderValues, onQuery }: QueryInterpreterOptions);
+    run(queryPlan: QueryPlanNode): Promise<unknown>;
+    private interpretNode;
+}

package/dist/interpreter/renderQuery.d.ts

@@ -0,0 +1,4 @@
+import { Query } from '@prisma/driver-adapter-utils';
+import { QueryPlanDbQuery } from '../QueryPlan';
+import { ScopeBindings } from './scope';
+export declare function renderQuery({ query, params }: QueryPlanDbQuery, scope: ScopeBindings): Query;

package/dist/interpreter/renderQueryTemplate.d.ts

@@ -0,0 +1,10 @@
+import { Value } from './scope';
+/**
+ * A `QueryPlanDbQuery` in which all placeholders have been substituted with
+ * their values from the environment.
+ */
+export type QueryWithSubstitutedPlaceholders = {
+    query: string;
+    params: Value[];
+};
+export declare function renderQueryTemplate({ query, params, }: QueryWithSubstitutedPlaceholders): QueryWithSubstitutedPlaceholders;

package/dist/interpreter/renderQueryTemplate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/interpreter/scope.d.ts

@@ -0,0 +1,13 @@
+/**
+ * An object like a record from the database.
+ */
+export type PrismaObject = Record<string, unknown>;
+/**
+ * The general type of values each node can evaluate to.
+ */
+export type Value = unknown;
+/**
+ * Scope in which a query plan node is interpreted. The names may come
+ * from the query placeholders or from let bindings introduced in the query plan.
+ */
+export type ScopeBindings = Record<string, unknown>;