@prisma/client-engine-runtime 6.7.0-integration-push-qwtnrmswnvqm.1 → 6.8.0-dev.1

package/dist/QueryPlan.d.ts

@@ -15,6 +15,38 @@ export type PrismaValueGenerator = {
 };
 export declare function isPrismaValueGenerator(value: unknown): value is PrismaValueGenerator;
 export type PrismaValue = string | boolean | number | PrismaValue[] | null | Record<string, unknown> | PrismaValuePlaceholder | PrismaValueGenerator;
+export type PrismaValueType = {
+    type: 'Any';
+} | {
+    type: 'String';
+} | {
+    type: 'Int';
+} | {
+    type: 'BigInt';
+} | {
+    type: 'Float';
+} | {
+    type: 'Boolean';
+} | {
+    type: 'Decimal';
+} | {
+    type: 'Date';
+} | {
+    type: 'Array';
+    inner: PrismaValueType;
+} | {
+    type: 'Object';
+} | {
+    type: 'Bytes';
+};
+export type ResultNode = {
+    type: 'Object';
+    fields: Record<string, ResultNode>;
+} | {
+    type: 'Value';
+    dbName: string;
+    resultType: PrismaValueType;
+};
 export type QueryPlanBinding = {
     name: string;
     expr: QueryPlanNode;
@@ -103,4 +135,10 @@ export type QueryPlanNode = {
 } | {
     type: 'transaction';
     args: QueryPlanNode;
+} | {
+    type: 'dataMap';
+    args: {
+        expr: QueryPlanNode;
+        structure: ResultNode;
+    };
 };

package/dist/index.d.mts

@@ -4,6 +4,7 @@ import type { Span } from '@opentelemetry/api';
 import type { SpanOptions } from '@opentelemetry/api';
 import { SqlDriverAdapter } from '@prisma/driver-adapter-utils';
 import { SqlQueryable } from '@prisma/driver-adapter-utils';
+import { SqlResultSet } from '@prisma/driver-adapter-utils';
 import { Transaction } from '@prisma/driver-adapter-utils';
 
 declare type ExtendedSpanOptions = SpanOptions & {
@@ -56,6 +57,31 @@ export declare type PrismaValuePlaceholder = {
     };
 };
 
+export declare type PrismaValueType = {
+    type: 'Any';
+} | {
+    type: 'String';
+} | {
+    type: 'Int';
+} | {
+    type: 'BigInt';
+} | {
+    type: 'Float';
+} | {
+    type: 'Boolean';
+} | {
+    type: 'Decimal';
+} | {
+    type: 'Date';
+} | {
+    type: 'Array';
+    inner: PrismaValueType;
+} | {
+    type: 'Object';
+} | {
+    type: 'Bytes';
+};
+
 export declare type QueryEvent = {
     timestamp: Date;
     query: string;
@@ -65,7 +91,13 @@ export declare type QueryEvent = {
 
 export declare class QueryInterpreter {
     #private;
-    constructor({ transactionManager, placeholderValues, onQuery, tracingHelper }: 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;
 }
@@ -75,6 +107,7 @@ export declare type QueryInterpreterOptions = {
     placeholderValues: Record<string, unknown>;
     onQuery?: (event: QueryEvent) => void;
     tracingHelper: TracingHelper;
+    serializer: (results: SqlResultSet) => Value;
 };
 
 export declare type QueryInterpreterTransactionManager = {
@@ -155,6 +188,21 @@ export declare type QueryPlanNode = {
 } | {
     type: 'transaction';
     args: QueryPlanNode;
+} | {
+    type: 'dataMap';
+    args: {
+        expr: QueryPlanNode;
+        structure: ResultNode;
+    };
+};
+
+export declare type ResultNode = {
+    type: 'Object';
+    fields: Record<string, ResultNode>;
+} | {
+    type: 'Value';
+    dbName: string;
+    resultType: PrismaValueType;
 };
 
 declare type SpanCallback<R> = (span?: Span, context?: Context) => R;
@@ -218,4 +266,9 @@ export declare class UserFacingError extends Error {
     };
 }
 
+/**
+ * The general type of values each node can evaluate to.
+ */
+declare type Value = unknown;
+
 export { }

package/dist/index.d.ts

@@ -4,6 +4,7 @@ import type { Span } from '@opentelemetry/api';
 import type { SpanOptions } from '@opentelemetry/api';
 import { SqlDriverAdapter } from '@prisma/driver-adapter-utils';
 import { SqlQueryable } from '@prisma/driver-adapter-utils';
+import { SqlResultSet } from '@prisma/driver-adapter-utils';
 import { Transaction } from '@prisma/driver-adapter-utils';
 
 declare type ExtendedSpanOptions = SpanOptions & {
@@ -56,6 +57,31 @@ export declare type PrismaValuePlaceholder = {
     };
 };
 
+export declare type PrismaValueType = {
+    type: 'Any';
+} | {
+    type: 'String';
+} | {
+    type: 'Int';
+} | {
+    type: 'BigInt';
+} | {
+    type: 'Float';
+} | {
+    type: 'Boolean';
+} | {
+    type: 'Decimal';
+} | {
+    type: 'Date';
+} | {
+    type: 'Array';
+    inner: PrismaValueType;
+} | {
+    type: 'Object';
+} | {
+    type: 'Bytes';
+};
+
 export declare type QueryEvent = {
     timestamp: Date;
     query: string;
@@ -65,7 +91,13 @@ export declare type QueryEvent = {
 
 export declare class QueryInterpreter {
     #private;
-    constructor({ transactionManager, placeholderValues, onQuery, tracingHelper }: 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;
 }
@@ -75,6 +107,7 @@ export declare type QueryInterpreterOptions = {
     placeholderValues: Record<string, unknown>;
     onQuery?: (event: QueryEvent) => void;
     tracingHelper: TracingHelper;
+    serializer: (results: SqlResultSet) => Value;
 };
 
 export declare type QueryInterpreterTransactionManager = {
@@ -155,6 +188,21 @@ export declare type QueryPlanNode = {
 } | {
     type: 'transaction';
     args: QueryPlanNode;
+} | {
+    type: 'dataMap';
+    args: {
+        expr: QueryPlanNode;
+        structure: ResultNode;
+    };
+};
+
+export declare type ResultNode = {
+    type: 'Object';
+    fields: Record<string, ResultNode>;
+} | {
+    type: 'Value';
+    dbName: string;
+    resultType: PrismaValueType;
 };
 
 declare type SpanCallback<R> = (span?: Span, context?: Context) => R;
@@ -218,4 +266,9 @@ export declare class UserFacingError extends Error {
     };
 }
 
+/**
+ * The general type of values each node can evaluate to.
+ */
+declare type Value = unknown;
+
 export { }

package/dist/index.js

@@ -210,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");
@@ -468,8 +562,8 @@ 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(".");
@@ -491,17 +585,28 @@ function serialize(resultSet) {
 }
 
 // src/interpreter/QueryInterpreter.ts
-var QueryInterpreter = class {
+var QueryInterpreter = class _QueryInterpreter {
   #transactionManager;
   #placeholderValues;
   #onQuery;
   #generators = new GeneratorRegistry();
   #tracingHelper;
-  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(
@@ -552,7 +657,7 @@ var QueryInterpreter = class {
       case "query": {
         const query = renderQuery(node.args, scope, generators);
         return this.#withQueryEvent(query, queryable, async () => {
-          return serialize(await queryable.queryRaw(query));
+          return this.#serializer(await queryable.queryRaw(query));
         });
       }
       case "reverse": {
@@ -602,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);
@@ -612,6 +717,10 @@ var QueryInterpreter = class {
           throw e;
         }
       }
+      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}`);
     }
@@ -734,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 {

package/dist/index.mjs

@@ -168,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";
@@ -426,8 +520,8 @@ 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(".");
@@ -449,17 +543,28 @@ function serialize(resultSet) {
 }
 
 // src/interpreter/QueryInterpreter.ts
-var QueryInterpreter = class {
+var QueryInterpreter = class _QueryInterpreter {
   #transactionManager;
   #placeholderValues;
   #onQuery;
   #generators = new GeneratorRegistry();
   #tracingHelper;
-  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(
@@ -510,7 +615,7 @@ var QueryInterpreter = class {
       case "query": {
         const query = renderQuery(node.args, scope, generators);
         return this.#withQueryEvent(query, queryable, async () => {
-          return serialize(await queryable.queryRaw(query));
+          return this.#serializer(await queryable.queryRaw(query));
         });
       }
       case "reverse": {
@@ -560,7 +665,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);
@@ -570,6 +675,10 @@ var QueryInterpreter = class {
           throw e;
         }
       }
+      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}`);
     }
@@ -692,7 +801,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 {

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,8 +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;
@@ -14,10 +15,17 @@ export type QueryInterpreterOptions = {
     placeholderValues: Record<string, unknown>;
     onQuery?: (event: QueryEvent) => void;
     tracingHelper: TracingHelper;
+    serializer: (results: SqlResultSet) => Value;
 };
 export declare class QueryInterpreter {
     #private;
-    constructor({ transactionManager, placeholderValues, onQuery, tracingHelper }: 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/client-engine-runtime",
-  "version": "6.7.0-integration-push-qwtnrmswnvqm.1",
+  "version": "6.8.0-dev.1",
   "description": "This package is intended for Prisma's internal use",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -30,8 +30,8 @@
     "nanoid": "5.1.5",
     "ulid": "3.0.0",
     "uuid": "11.1.0",
-    "@prisma/debug": "6.7.0-integration-push-qwtnrmswnvqm.1",
-    "@prisma/driver-adapter-utils": "6.7.0-integration-push-qwtnrmswnvqm.1"
+    "@prisma/debug": "6.8.0-dev.1",
+    "@prisma/driver-adapter-utils": "6.8.0-dev.1"
   },
   "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>[];