@vantreeseba/drizzle-graphql 5.4.0 → 5.6.0

package/dist/index.js

@@ -17,6 +17,7 @@ import {
   asc,
   desc,
   eq,
+  extractExtendedColumnType as extractExtendedColumnType2,
   getColumns,
   getTableAsAliasSQL,
   gt,
@@ -104,8 +105,287 @@ var uncapitalize = (input) => input?.length ? `${input[0].toLocaleLowerCase()}${
 var capitalize = (input) => input?.length ? `${input[0].toLocaleUpperCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
 
 // src/util/data-mappers/index.ts
-import { getTableColumns, is, One } from "drizzle-orm";
-import { GraphQLError } from "graphql";
+import { getTableColumns as getTableColumns2, is as is2, One } from "drizzle-orm";
+import { GraphQLError as GraphQLError2 } from "graphql";
+
+// src/util/type-converter/index.ts
+import { extractExtendedColumnType, getTableColumns, is } from "drizzle-orm";
+import { MySqlInt, MySqlSerial } from "drizzle-orm/mysql-core";
+import { PgDate, PgDateString, PgInteger, PgSerial, PgTimestamp, PgTimestampString, PgUUID } from "drizzle-orm/pg-core";
+import { SQLiteInteger } from "drizzle-orm/sqlite-core";
+import {
+  GraphQLBoolean,
+  GraphQLEnumType,
+  GraphQLFloat,
+  GraphQLInputObjectType,
+  GraphQLInt,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLScalarType as GraphQLScalarType2,
+  GraphQLString
+} from "graphql";
+
+// src/util/scalars/index.ts
+import { GraphQLError, GraphQLScalarType, Kind } from "graphql";
+import { GraphQLDate, GraphQLDateTime, GraphQLJSON, GraphQLUUID } from "graphql-scalars";
+var asDecimalString = (value) => {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number") {
+    if (!Number.isInteger(value)) {
+      throw new GraphQLError(`BigInt cannot represent non-integer value: ${value}`);
+    }
+    if (!Number.isSafeInteger(value)) {
+      throw new GraphQLError(
+        `BigInt cannot represent the number ${value} without precision loss \u2014 pass it as a string instead`
+      );
+    }
+    return String(value);
+  }
+  if (typeof value === "string") {
+    if (!/^-?\d+$/.test(value)) {
+      throw new GraphQLError(`BigInt cannot represent non-integer value: "${value}"`);
+    }
+    return value;
+  }
+  throw new GraphQLError(`BigInt cannot represent value: ${JSON.stringify(value)}`);
+};
+var GraphQLBigIntString = new GraphQLScalarType({
+  name: "BigInt",
+  description: "A 64-bit integer, transported as a decimal string so that values beyond JavaScript's safe integer range survive the round-trip intact.",
+  serialize: asDecimalString,
+  parseValue: asDecimalString,
+  parseLiteral: (ast) => {
+    if (ast.kind !== Kind.STRING && ast.kind !== Kind.INT) {
+      throw new GraphQLError(`BigInt cannot represent a ${ast.kind}`, { nodes: ast });
+    }
+    return asDecimalString(ast.value);
+  }
+});
+var numericStringPattern = /^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$/;
+var asNumericString = (value) => {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new GraphQLError(`Decimal cannot represent non-finite value: ${value}`);
+    }
+    return String(value);
+  }
+  if (typeof value === "string") {
+    if (!numericStringPattern.test(value)) {
+      throw new GraphQLError(`Decimal cannot represent non-numeric value: "${value}"`);
+    }
+    return value;
+  }
+  throw new GraphQLError(`Decimal cannot represent value: ${JSON.stringify(value)}`);
+};
+var GraphQLDecimalString = new GraphQLScalarType({
+  name: "Decimal",
+  description: "An arbitrary-precision decimal, transported as a numeric string so that values beyond JavaScript's double-precision range survive the round-trip intact.",
+  serialize: asNumericString,
+  parseValue: asNumericString,
+  parseLiteral: (ast) => {
+    if (ast.kind !== Kind.STRING && ast.kind !== Kind.INT && ast.kind !== Kind.FLOAT) {
+      throw new GraphQLError(`Decimal cannot represent a ${ast.kind}`, { nodes: ast });
+    }
+    return asNumericString(ast.value);
+  }
+});
+
+// src/util/type-converter/index.ts
+var allowedNameChars = /^[a-zA-Z0-9_]+$/;
+var enumMap = /* @__PURE__ */ new WeakMap();
+var generateEnumCached = (column, columnName, tableName) => {
+  if (enumMap.has(column)) {
+    return enumMap.get(column);
+  }
+  const gqlEnum = new GraphQLEnumType({
+    name: `${capitalize(tableName)}${capitalize(columnName)}Enum`,
+    values: Object.fromEntries(
+      column.enumValues.map((e, index) => [
+        allowedNameChars.test(e) ? e : `Option${index}`,
+        {
+          value: e,
+          description: `Value: ${e}`
+        }
+      ])
+    )
+  });
+  enumMap.set(column, gqlEnum);
+  return gqlEnum;
+};
+var geoXyType = new GraphQLObjectType({
+  name: "PgGeometryObject",
+  fields: {
+    x: { type: GraphQLFloat },
+    y: { type: GraphQLFloat }
+  }
+});
+var geoXyInputType = new GraphQLInputObjectType({
+  name: "PgGeometryObjectInput",
+  fields: {
+    x: { type: GraphQLFloat },
+    y: { type: GraphQLFloat }
+  }
+});
+var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
+  const dimensions = column.dimensions;
+  if (dimensions !== void 0 && dimensions > 0) {
+    const inner = columnBaseToGraphQLCore(column, columnName, tableName, isInput);
+    const innerDesc = inner.description ?? inner.type.name;
+    let type = inner.type;
+    let description = innerDesc;
+    for (let i = 0; i < dimensions; i++) {
+      type = new GraphQLList(new GraphQLNonNull(type));
+      description = `Array<${description}>`;
+    }
+    return { type, description };
+  }
+  return columnBaseToGraphQLCore(column, columnName, tableName, isInput);
+};
+var columnBaseToGraphQLCore = (column, columnName, tableName, isInput) => {
+  const { type: baseType, constraint } = extractExtendedColumnType(column);
+  switch (baseType) {
+    case "boolean":
+      return { type: GraphQLBoolean, description: "Boolean" };
+    case "object":
+      if (column instanceof PgTimestamp || column instanceof PgDate) {
+        return { type: GraphQLDateTime, description: "DateTime" };
+      }
+      return column.columnType === "PgGeometryObject" ? {
+        type: isInput ? geoXyInputType : geoXyType,
+        description: "Geometry points XY"
+      } : column.columnType === "PgBytea" ? {
+        type: new GraphQLList(new GraphQLNonNull(GraphQLInt)),
+        description: "Buffer"
+      } : { type: GraphQLJSON, description: "JSON" };
+    case "string":
+      if (column.enumValues?.length) {
+        return { type: generateEnumCached(column, columnName, tableName) };
+      }
+      if (constraint === "numeric" && !column.dimensions) {
+        return { type: GraphQLDecimalString, description: "Decimal" };
+      }
+      if (column instanceof PgTimestamp || column instanceof PgTimestampString) {
+        return { type: GraphQLDateTime, description: "DateTime" };
+      }
+      if (column instanceof PgUUID) {
+        return { type: GraphQLUUID, description: "UUID" };
+      }
+      if (column instanceof PgDateString) {
+        return isInput ? { type: GraphQLString, description: "Date" } : { type: GraphQLDate, description: "Date" };
+      }
+      return { type: GraphQLString, description: "String" };
+    case "bigint":
+      return { type: GraphQLBigIntString, description: "BigInt" };
+    case "number": {
+      return is(column, PgInteger) || is(column, PgSerial) || is(column, MySqlInt) || is(column, MySqlSerial) || is(column, SQLiteInteger) ? { type: GraphQLInt, description: "Integer" } : { type: GraphQLFloat, description: "Float" };
+    }
+    case "array": {
+      if (column.columnType === "PgVector") {
+        return {
+          type: new GraphQLList(new GraphQLNonNull(GraphQLFloat)),
+          description: "Array<Float>"
+        };
+      }
+      if (column.columnType === "PgGeometry") {
+        return {
+          type: new GraphQLList(new GraphQLNonNull(GraphQLFloat)),
+          description: "Tuple<[Float, Float]>"
+        };
+      }
+      const innerType = columnToGraphQLCore(
+        column.baseColumn,
+        columnName,
+        tableName,
+        isInput
+      );
+      return {
+        type: new GraphQLList(new GraphQLNonNull(innerType.type)),
+        description: `Array<${innerType.description}>`
+      };
+    }
+    default:
+      throw new Error(`Drizzle-GraphQL Error: Type ${column.dataType} is not implemented!`);
+  }
+};
+var columnScalarOverrides = /* @__PURE__ */ new WeakMap();
+var getColumnScalarOverride = (column, isInput) => {
+  const override = columnScalarOverrides.get(column);
+  return override ? isInput ? override.input : override.output : void 0;
+};
+var normalizeScalarOverride = (override, tableName, columnName) => {
+  const pair = override instanceof GraphQLScalarType2 ? { output: override, input: override } : { output: override.output, input: override.input };
+  for (const scalar of [pair.output, pair.input]) {
+    if (scalar !== void 0 && !(scalar instanceof GraphQLScalarType2)) {
+      throw new Error(
+        `Drizzle-GraphQL Error: Scalar override for column '${tableName}.${columnName}' must be a GraphQLScalarType!`
+      );
+    }
+  }
+  return pair;
+};
+var registerScalarOverrides = (tables, config) => {
+  for (const [tableName, table] of Object.entries(tables)) {
+    for (const [columnName, column] of Object.entries(getTableColumns(table))) {
+      const declared = config.scalars?.[tableName]?.[columnName];
+      let resolved;
+      if (declared !== void 0) {
+        resolved = normalizeScalarOverride(declared, tableName, columnName);
+      } else if (config.mapColumnType) {
+        let defaultType;
+        let defaultInputType;
+        try {
+          defaultType = columnToGraphQLCore(column, columnName, tableName, false).type;
+        } catch {
+        }
+        try {
+          defaultInputType = columnToGraphQLCore(column, columnName, tableName, true).type;
+        } catch {
+        }
+        const mapped = config.mapColumnType(column, { tableName, columnName, defaultType, defaultInputType });
+        if (mapped !== void 0) {
+          resolved = normalizeScalarOverride(mapped, tableName, columnName);
+        }
+      }
+      if (resolved && (resolved.output !== void 0 || resolved.input !== void 0)) {
+        columnScalarOverrides.set(column, resolved);
+      } else {
+        columnScalarOverrides.delete(column);
+      }
+    }
+  }
+};
+var drizzleColumnToGraphQLType = (column, columnName, tableName, forceNullable = false, defaultIsNullable = false, isInput = false) => {
+  const override = getColumnScalarOverride(column, isInput);
+  let typeDesc;
+  if (override) {
+    typeDesc = { type: override, description: override.name };
+  } else {
+    typeDesc = columnToGraphQLCore(column, columnName, tableName, isInput);
+    const noDesc = ["string", "boolean", "number"];
+    const { type: baseType } = extractExtendedColumnType(column);
+    if (noDesc.find((e) => e === baseType)) {
+      delete typeDesc.description;
+    }
+  }
+  if (forceNullable) {
+    return typeDesc;
+  }
+  if (column.notNull && !(defaultIsNullable && (column.hasDefault || column.defaultFn))) {
+    return {
+      type: new GraphQLNonNull(typeDesc.type),
+      description: typeDesc.description
+    };
+  }
+  return typeDesc;
+};
+
+// src/util/data-mappers/index.ts
 var isJsonColumn = (column) => (column.dataType ?? "").includes("json") && column.columnType !== "PgGeometryObject";
 var remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
   if (Array.isArray(value)) {
@@ -136,6 +416,9 @@ var remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
   if (!column) {
     return value;
   }
+  if (getColumnScalarOverride(column, false)) {
+    return value;
+  }
   if (isJsonColumn(column)) {
     return value;
   }
@@ -166,7 +449,7 @@ var remapToGraphQLSingleOutput = (queryOutput, tableName, table, relationMap) =>
   for (const [key, value] of Object.entries(queryOutput)) {
     if (value === void 0 || value === null) {
       const relEntry = value === null ? relationMap?.[tableName]?.[key] : void 0;
-      if (relEntry && is(relEntry.relation, One)) {
+      if (relEntry && is2(relEntry.relation, One)) {
         queryOutput[key] = null;
         continue;
       }
@@ -189,13 +472,19 @@ var remapToGraphQLArrayOutput = (queryOutput, tableName, table, relationMap) =>
   return queryOutput;
 };
 var remapFromGraphQLCore = (value, column, columnName) => {
+  if (getColumnScalarOverride(column, true)) {
+    if (typeof value === "object" && value !== null && Object.getPrototypeOf(value) === null) {
+      return Object.assign({}, value);
+    }
+    return value;
+  }
   const dataType = column.dataType ?? "";
   const columnType = column.columnType ?? "";
   const isTimestampColumn = columnType === "SQLiteTimestamp" || columnType === "SQLiteTimestampMs" || columnType === "MySqlTimestamp" || columnType === "MySqlDateTime" || columnType === "PgTimestamp" || columnType === "PgTimestampString";
   if (isTimestampColumn) {
     const formatted = new Date(value);
     if (Number.isNaN(formatted.getTime())) {
-      throw new GraphQLError(`Field '${columnName}' is not a valid date!`);
+      throw new GraphQLError2(`Field '${columnName}' is not a valid date!`);
     }
     return formatted;
   }
@@ -204,7 +493,7 @@ var remapFromGraphQLCore = (value, column, columnName) => {
     const dateOnly = value.includes("T") ? value.split("T")[0] : value;
     const check = new Date(dateOnly);
     if (Number.isNaN(check.getTime())) {
-      throw new GraphQLError(`Field '${columnName}' is not a valid date!`);
+      throw new GraphQLError2(`Field '${columnName}' is not a valid date!`);
     }
     return dateOnly;
   }
@@ -212,7 +501,7 @@ var remapFromGraphQLCore = (value, column, columnName) => {
     try {
       return BigInt(value);
     } catch {
-      throw new GraphQLError(`Field '${columnName}' is not a BigInt!`);
+      throw new GraphQLError2(`Field '${columnName}' is not a BigInt!`);
     }
   }
   if (dataType.includes("json") && column.columnType !== "PgGeometryObject") {
@@ -222,13 +511,13 @@ var remapFromGraphQLCore = (value, column, columnName) => {
     case "date": {
       const formatted = new Date(value);
       if (Number.isNaN(formatted.getTime())) {
-        throw new GraphQLError(`Field '${columnName}' is not a valid date!`);
+        throw new GraphQLError2(`Field '${columnName}' is not a valid date!`);
       }
       return formatted;
     }
     case "buffer": {
       if (!Array.isArray(value)) {
-        throw new GraphQLError(`Field '${columnName}' is not an array!`);
+        throw new GraphQLError2(`Field '${columnName}' is not an array!`);
       }
       return Buffer.from(value);
     }
@@ -239,7 +528,7 @@ var remapFromGraphQLCore = (value, column, columnName) => {
       try {
         return JSON.parse(value);
       } catch (e) {
-        throw new GraphQLError(
+        throw new GraphQLError2(
           `Invalid JSON in field '${columnName}':
 ${e instanceof Error ? e.message : "Unknown error"}`
         );
@@ -247,10 +536,10 @@ ${e instanceof Error ? e.message : "Unknown error"}`
     }
     case "array": {
       if (!Array.isArray(value)) {
-        throw new GraphQLError(`Field '${columnName}' is not an array!`);
+        throw new GraphQLError2(`Field '${columnName}' is not an array!`);
       }
       if (column.columnType === "PgGeometry" && value.length !== 2) {
-        throw new GraphQLError(
+        throw new GraphQLError2(
           `Invalid float tuple in field '${columnName}': expected array with length of 2, received ${value.length}`
         );
       }
@@ -260,7 +549,7 @@ ${e instanceof Error ? e.message : "Unknown error"}`
       try {
         return BigInt(value);
       } catch (_error) {
-        throw new GraphQLError(`Field '${columnName}' is not a BigInt!`);
+        throw new GraphQLError2(`Field '${columnName}' is not a BigInt!`);
       }
     }
     default: {
@@ -276,245 +565,24 @@ var remapFromGraphQLSingleInput = (queryInput, table) => {
     if (value === void 0) {
       delete queryInput[key];
     } else {
-      const column = getTableColumns(table)[key];
+      const column = getTableColumns2(table)[key];
       if (!column) {
-        throw new GraphQLError(`Unknown column: ${key}`);
+        throw new GraphQLError2(`Unknown column: ${key}`);
       }
       if (value === null && column.notNull) {
         delete queryInput[key];
-        continue;
-      }
-      queryInput[key] = remapFromGraphQLCore(value, column, key);
-    }
-  }
-  return queryInput;
-};
-var remapFromGraphQLArrayInput = (queryInput, table) => {
-  for (const entry of queryInput) {
-    remapFromGraphQLSingleInput(entry, table);
-  }
-  return queryInput;
-};
-
-// src/util/scalars/index.ts
-import { GraphQLError as GraphQLError2, GraphQLScalarType, Kind } from "graphql";
-import { GraphQLDate, GraphQLDateTime, GraphQLJSON, GraphQLUUID } from "graphql-scalars";
-var asDecimalString = (value) => {
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  if (typeof value === "number") {
-    if (!Number.isInteger(value)) {
-      throw new GraphQLError2(`BigInt cannot represent non-integer value: ${value}`);
-    }
-    if (!Number.isSafeInteger(value)) {
-      throw new GraphQLError2(
-        `BigInt cannot represent the number ${value} without precision loss \u2014 pass it as a string instead`
-      );
-    }
-    return String(value);
-  }
-  if (typeof value === "string") {
-    if (!/^-?\d+$/.test(value)) {
-      throw new GraphQLError2(`BigInt cannot represent non-integer value: "${value}"`);
-    }
-    return value;
-  }
-  throw new GraphQLError2(`BigInt cannot represent value: ${JSON.stringify(value)}`);
-};
-var GraphQLBigIntString = new GraphQLScalarType({
-  name: "BigInt",
-  description: "A 64-bit integer, transported as a decimal string so that values beyond JavaScript's safe integer range survive the round-trip intact.",
-  serialize: asDecimalString,
-  parseValue: asDecimalString,
-  parseLiteral: (ast) => {
-    if (ast.kind !== Kind.STRING && ast.kind !== Kind.INT) {
-      throw new GraphQLError2(`BigInt cannot represent a ${ast.kind}`, { nodes: ast });
-    }
-    return asDecimalString(ast.value);
-  }
-});
-var numericStringPattern = /^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$/;
-var asNumericString = (value) => {
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new GraphQLError2(`Decimal cannot represent non-finite value: ${value}`);
-    }
-    return String(value);
-  }
-  if (typeof value === "string") {
-    if (!numericStringPattern.test(value)) {
-      throw new GraphQLError2(`Decimal cannot represent non-numeric value: "${value}"`);
-    }
-    return value;
-  }
-  throw new GraphQLError2(`Decimal cannot represent value: ${JSON.stringify(value)}`);
-};
-var GraphQLDecimalString = new GraphQLScalarType({
-  name: "Decimal",
-  description: "An arbitrary-precision decimal, transported as a numeric string so that values beyond JavaScript's double-precision range survive the round-trip intact.",
-  serialize: asNumericString,
-  parseValue: asNumericString,
-  parseLiteral: (ast) => {
-    if (ast.kind !== Kind.STRING && ast.kind !== Kind.INT && ast.kind !== Kind.FLOAT) {
-      throw new GraphQLError2(`Decimal cannot represent a ${ast.kind}`, { nodes: ast });
-    }
-    return asNumericString(ast.value);
-  }
-});
-
-// src/util/type-converter/index.ts
-import { extractExtendedColumnType, is as is2 } from "drizzle-orm";
-import { MySqlInt, MySqlSerial } from "drizzle-orm/mysql-core";
-import { PgDate, PgDateString, PgInteger, PgSerial, PgTimestamp, PgTimestampString, PgUUID } from "drizzle-orm/pg-core";
-import { SQLiteInteger } from "drizzle-orm/sqlite-core";
-import {
-  GraphQLBoolean,
-  GraphQLEnumType,
-  GraphQLFloat,
-  GraphQLInputObjectType,
-  GraphQLInt,
-  GraphQLList,
-  GraphQLNonNull,
-  GraphQLObjectType,
-  GraphQLString
-} from "graphql";
-var allowedNameChars = /^[a-zA-Z0-9_]+$/;
-var enumMap = /* @__PURE__ */ new WeakMap();
-var generateEnumCached = (column, columnName, tableName) => {
-  if (enumMap.has(column)) {
-    return enumMap.get(column);
-  }
-  const gqlEnum = new GraphQLEnumType({
-    name: `${capitalize(tableName)}${capitalize(columnName)}Enum`,
-    values: Object.fromEntries(
-      column.enumValues.map((e, index) => [
-        allowedNameChars.test(e) ? e : `Option${index}`,
-        {
-          value: e,
-          description: `Value: ${e}`
-        }
-      ])
-    )
-  });
-  enumMap.set(column, gqlEnum);
-  return gqlEnum;
-};
-var geoXyType = new GraphQLObjectType({
-  name: "PgGeometryObject",
-  fields: {
-    x: { type: GraphQLFloat },
-    y: { type: GraphQLFloat }
-  }
-});
-var geoXyInputType = new GraphQLInputObjectType({
-  name: "PgGeometryObjectInput",
-  fields: {
-    x: { type: GraphQLFloat },
-    y: { type: GraphQLFloat }
-  }
-});
-var columnToGraphQLCore = (column, columnName, tableName, isInput) => {
-  const dimensions = column.dimensions;
-  if (dimensions !== void 0 && dimensions > 0) {
-    const inner = columnBaseToGraphQLCore(column, columnName, tableName, isInput);
-    const innerDesc = inner.description ?? inner.type.name;
-    let type = inner.type;
-    let description = innerDesc;
-    for (let i = 0; i < dimensions; i++) {
-      type = new GraphQLList(new GraphQLNonNull(type));
-      description = `Array<${description}>`;
-    }
-    return { type, description };
-  }
-  return columnBaseToGraphQLCore(column, columnName, tableName, isInput);
-};
-var columnBaseToGraphQLCore = (column, columnName, tableName, isInput) => {
-  const { type: baseType, constraint } = extractExtendedColumnType(column);
-  switch (baseType) {
-    case "boolean":
-      return { type: GraphQLBoolean, description: "Boolean" };
-    case "object":
-      if (column instanceof PgTimestamp || column instanceof PgDate) {
-        return { type: GraphQLDateTime, description: "DateTime" };
-      }
-      return column.columnType === "PgGeometryObject" ? {
-        type: isInput ? geoXyInputType : geoXyType,
-        description: "Geometry points XY"
-      } : column.columnType === "PgBytea" ? {
-        type: new GraphQLList(new GraphQLNonNull(GraphQLInt)),
-        description: "Buffer"
-      } : { type: GraphQLJSON, description: "JSON" };
-    case "string":
-      if (column.enumValues?.length) {
-        return { type: generateEnumCached(column, columnName, tableName) };
-      }
-      if (constraint === "numeric" && !column.dimensions) {
-        return { type: GraphQLDecimalString, description: "Decimal" };
-      }
-      if (column instanceof PgTimestamp || column instanceof PgTimestampString) {
-        return { type: GraphQLDateTime, description: "DateTime" };
-      }
-      if (column instanceof PgUUID) {
-        return { type: GraphQLUUID, description: "UUID" };
-      }
-      if (column instanceof PgDateString) {
-        return isInput ? { type: GraphQLString, description: "Date" } : { type: GraphQLDate, description: "Date" };
-      }
-      return { type: GraphQLString, description: "String" };
-    case "bigint":
-      return { type: GraphQLBigIntString, description: "BigInt" };
-    case "number": {
-      return is2(column, PgInteger) || is2(column, PgSerial) || is2(column, MySqlInt) || is2(column, MySqlSerial) || is2(column, SQLiteInteger) ? { type: GraphQLInt, description: "Integer" } : { type: GraphQLFloat, description: "Float" };
-    }
-    case "array": {
-      if (column.columnType === "PgVector") {
-        return {
-          type: new GraphQLList(new GraphQLNonNull(GraphQLFloat)),
-          description: "Array<Float>"
-        };
-      }
-      if (column.columnType === "PgGeometry") {
-        return {
-          type: new GraphQLList(new GraphQLNonNull(GraphQLFloat)),
-          description: "Tuple<[Float, Float]>"
-        };
+        continue;
       }
-      const innerType = columnToGraphQLCore(
-        column.baseColumn,
-        columnName,
-        tableName,
-        isInput
-      );
-      return {
-        type: new GraphQLList(new GraphQLNonNull(innerType.type)),
-        description: `Array<${innerType.description}>`
-      };
+      queryInput[key] = remapFromGraphQLCore(value, column, key);
     }
-    default:
-      throw new Error(`Drizzle-GraphQL Error: Type ${column.dataType} is not implemented!`);
   }
+  return queryInput;
 };
-var drizzleColumnToGraphQLType = (column, columnName, tableName, forceNullable = false, defaultIsNullable = false, isInput = false) => {
-  const typeDesc = columnToGraphQLCore(column, columnName, tableName, isInput);
-  const noDesc = ["string", "boolean", "number"];
-  const { type: baseType } = extractExtendedColumnType(column);
-  if (noDesc.find((e) => e === baseType)) {
-    delete typeDesc.description;
-  }
-  if (forceNullable) {
-    return typeDesc;
-  }
-  if (column.notNull && !(defaultIsNullable && (column.hasDefault || column.defaultFn))) {
-    return {
-      type: new GraphQLNonNull(typeDesc.type),
-      description: typeDesc.description
-    };
+var remapFromGraphQLArrayInput = (queryInput, table) => {
+  for (const entry of queryInput) {
+    remapFromGraphQLSingleInput(entry, table);
   }
-  return typeDesc;
+  return queryInput;
 };
 
 // src/util/builders/common.ts
@@ -605,6 +673,203 @@ var resolveQueryExecutor = (db, context, tableName, buildTimeQueryBase) => {
     queryBase: buildTimeQueryBase ? executor?.query?.[tableName] ?? buildTimeQueryBase : buildTimeQueryBase
   };
 };
+var createMutationTxCtx = (options) => options ? { timeoutMs: options.timeoutMs, fieldNames: /* @__PURE__ */ new Set(), states: /* @__PURE__ */ new WeakMap() } : void 0;
+var includedByDirectives = (node, variables) => {
+  for (const directive of node.directives ?? []) {
+    const name = directive.name.value;
+    if (name !== "skip" && name !== "include") {
+      continue;
+    }
+    const ifArg = directive.arguments?.find((arg) => arg.name.value === "if");
+    let value;
+    if (ifArg?.value.kind === "BooleanValue") {
+      value = ifArg.value.value;
+    } else if (ifArg?.value.kind === "Variable") {
+      value = variables?.[ifArg.value.name.value];
+    }
+    if (name === "skip" && value === true) {
+      return false;
+    }
+    if (name === "include" && value !== true) {
+      return false;
+    }
+  }
+  return true;
+};
+var collectRootMutationKeys = (selectionSet, fragments, variables, known, keys, visitedFragments) => {
+  for (const selection of selectionSet.selections) {
+    if (!includedByDirectives(selection, variables)) {
+      continue;
+    }
+    if (selection.kind === "Field") {
+      const name = selection.name.value;
+      if (name === "__typename") {
+        continue;
+      }
+      if (!known.has(name)) {
+        return false;
+      }
+      keys.add(selection.alias?.value ?? name);
+    } else if (selection.kind === "InlineFragment") {
+      if (!collectRootMutationKeys(selection.selectionSet, fragments, variables, known, keys, visitedFragments)) {
+        return false;
+      }
+    } else if (selection.kind === "FragmentSpread") {
+      const fragmentName = selection.name.value;
+      if (visitedFragments.has(fragmentName)) {
+        continue;
+      }
+      visitedFragments.add(fragmentName);
+      const fragment = fragments?.[fragmentName];
+      if (!fragment) {
+        return false;
+      }
+      if (!collectRootMutationKeys(fragment.selectionSet, fragments, variables, known, keys, visitedFragments)) {
+        return false;
+      }
+    }
+  }
+  return true;
+};
+var abortedBatchError = () => new GraphQLError3(
+  "Drizzle-GraphQL Error: Mutation was not executed because an earlier mutation in the same request failed and the shared transaction was rolled back."
+);
+var openSharedTx = (db, context, txCtx, stateKey, expected) => {
+  let release;
+  let rejectLatch;
+  const latch = new Promise((resolve, reject) => {
+    release = resolve;
+    rejectLatch = reject;
+  });
+  let readyResolve;
+  let readyReject;
+  const ready = new Promise((resolve, reject) => {
+    readyResolve = resolve;
+    readyReject = reject;
+  });
+  ready.catch(() => {
+  });
+  const canStash = context !== null && typeof context === "object" && !Object.isFrozen(context);
+  const settled = db.transaction(async (tx) => {
+    if (canStash) {
+      context[drizzleExecutorKey] = tx;
+    }
+    readyResolve(tx);
+    await latch;
+  });
+  let timer;
+  const clearTimer = () => {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  };
+  const state = {
+    kind: "shared",
+    expected,
+    completed: 0,
+    failure: void 0,
+    aborted: false,
+    done: false,
+    ready,
+    settled,
+    release,
+    abort: (e) => {
+      if (!state.aborted) {
+        state.aborted = true;
+        state.failure = e;
+      }
+      rejectLatch(e);
+    },
+    suspendTimer: clearTimer,
+    bumpTimer: () => {
+      clearTimer();
+      if (state.done) {
+        return;
+      }
+      timer = setTimeout(() => {
+        state.abort(
+          new GraphQLError3(
+            `Drizzle-GraphQL Error: Shared mutation transaction timed out after ${txCtx.timeoutMs}ms waiting for the remaining mutation fields; rolling back.`
+          )
+        );
+      }, txCtx.timeoutMs);
+      timer.unref?.();
+    }
+  };
+  const cleanup = () => {
+    state.done = true;
+    clearTimer();
+    if (canStash) {
+      delete context[drizzleExecutorKey];
+    }
+    if (!state.aborted) {
+      txCtx.states.delete(stateKey);
+    }
+  };
+  settled.then(cleanup, (e) => {
+    cleanup();
+    readyReject(e);
+  });
+  state.bumpTimer();
+  return state;
+};
+var runOnSharedTx = async (state, body) => {
+  if (state.aborted) {
+    await state.settled.catch(() => {
+    });
+    throw abortedBatchError();
+  }
+  state.suspendTimer();
+  const tx = await state.ready;
+  try {
+    if (state.aborted) {
+      throw abortedBatchError();
+    }
+    const result = await body(tx);
+    state.completed += 1;
+    if (state.completed >= state.expected) {
+      state.release();
+      await state.settled;
+    } else {
+      state.bumpTimer();
+    }
+    return result;
+  } catch (e) {
+    state.abort(e);
+    await state.settled.catch(() => {
+    });
+    throw e;
+  }
+};
+var runMutation = async (db, context, info, txCtx, body) => {
+  const contextIsObject = context !== null && (typeof context === "object" || typeof context === "function");
+  const stateKey = contextIsObject ? context : info.operation;
+  let state = txCtx?.states.get(stateKey);
+  if (!state) {
+    if (contextIsObject && context[drizzleExecutorKey]) {
+      return body(context[drizzleExecutorKey]);
+    }
+    if (!txCtx || info.operation.operation !== "mutation") {
+      return body(db);
+    }
+    const keys = /* @__PURE__ */ new Set();
+    const allKnown = collectRootMutationKeys(
+      info.operation.selectionSet,
+      info.fragments,
+      info.variableValues,
+      txCtx.fieldNames,
+      keys,
+      /* @__PURE__ */ new Set()
+    );
+    state = !allKnown || keys.size <= 1 ? { kind: "passthrough" } : openSharedTx(db, context, txCtx, stateKey, keys.size);
+    txCtx.states.set(stateKey, state);
+  }
+  if (state.kind === "passthrough") {
+    return body(resolveExecutor(db, context));
+  }
+  return runOnSharedTx(state, body);
+};
 var batchedPaginatedRelationQuery = async (db, targetTable, foreignCol, whereCondition, orderByArg, limit, offset, pkNames, orderCtx) => {
   const cols = getColumns(targetTable);
   const orderExprs = [
@@ -898,9 +1163,31 @@ var arrayFilterFields = (colType, colArr, colDesc) => {
   };
 };
 var FILTERS_WITHOUT_STRING_OPS = /* @__PURE__ */ new Set(["Id", "Int", "Float", "BigInt", "Decimal"]);
+var BUILTIN_FILTER_SCALARS = /* @__PURE__ */ new Set([
+  GraphQLString2,
+  GraphQLInt2,
+  GraphQLFloat2,
+  GraphQLBoolean2,
+  GraphQLBigIntString,
+  GraphQLDecimalString,
+  GraphQLUUID,
+  GraphQLJSON,
+  GraphQLDate,
+  GraphQLDateTime
+]);
+var resolveOverrideFilterDescriptor = (scalar) => {
+  if (scalar === GraphQLJSON) {
+    return { name: "JSON", kind: "json" };
+  }
+  if (scalar === GraphQLUUID) {
+    return { name: "Id", kind: "scalar" };
+  }
+  return { name: scalar.name, kind: "scalar" };
+};
 var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
   const columnGraphQLType = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, true);
-  const { name: genericName, kind } = resolveGenericFilterDescriptor(column, columnGraphQLType);
+  const inputOverride = getColumnScalarOverride(column, true);
+  const { name: genericName, kind } = inputOverride ? resolveOverrideFilterDescriptor(inputOverride) : resolveGenericFilterDescriptor(column, columnGraphQLType);
   const cached = cacheCtx.genericFilterCache.get(genericName);
   if (cached) {
     return cached;
@@ -908,7 +1195,9 @@ var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
   const colType = columnGraphQLType.type;
   const colDesc = columnGraphQLType.description;
   const colArr = new GraphQLList2(new GraphQLNonNull2(colType));
-  const omitStringOps = FILTERS_WITHOUT_STRING_OPS.has(genericName);
+  const customOverrideFilter = inputOverride !== void 0 && !BUILTIN_FILTER_SCALARS.has(inputOverride);
+  const underlying = extractExtendedColumnType2(column);
+  const omitStringOps = customOverrideFilter ? underlying.type !== "string" || underlying.constraint === "numeric" : FILTERS_WITHOUT_STRING_OPS.has(genericName);
   const baseFields = kind === "json" ? jsonFilterFields(column, colType) : kind === "array" ? arrayFilterFields(colType, colArr, colDesc) : {
     eq: { type: colType, description: colDesc },
     ne: { type: colType, description: colDesc },
@@ -989,10 +1278,9 @@ var generateTableOrderCached = (table) => {
   }
   return remapped;
 };
-var filterMap = /* @__PURE__ */ new WeakMap();
 var generateTableFilterValuesCached = (table, tableName, cacheCtx) => {
-  if (filterMap.has(table)) {
-    return filterMap.get(table);
+  if (cacheCtx.filterFieldCache.has(table)) {
+    return cacheCtx.filterFieldCache.get(table);
   }
   const columns = getColumns(table);
   const columnEntries = Object.entries(columns);
@@ -1004,13 +1292,12 @@ var generateTableFilterValuesCached = (table, tableName, cacheCtx) => {
       }
     ])
   );
-  filterMap.set(table, remapped);
+  cacheCtx.filterFieldCache.set(table, remapped);
   return remapped;
 };
-var fieldMap = /* @__PURE__ */ new WeakMap();
-var generateTableSelectTypeFieldsCached = (table, tableName) => {
-  if (fieldMap.has(table)) {
-    return fieldMap.get(table);
+var generateTableSelectTypeFieldsCached = (table, tableName, cacheCtx) => {
+  if (cacheCtx.selectFieldCache.has(table)) {
+    return cacheCtx.selectFieldCache.get(table);
   }
   const columns = getColumns(table);
   const columnEntries = Object.entries(columns);
@@ -1027,7 +1314,7 @@ var generateTableSelectTypeFieldsCached = (table, tableName) => {
       resolve: rowCursorResolver
     };
   }
-  fieldMap.set(table, remapped);
+  cacheCtx.selectFieldCache.set(table, remapped);
   return remapped;
 };
 var isFilterableRelation = (relation) => !relation.through;
@@ -1177,7 +1464,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
   const table = tables[tableName];
   const order = withOrder ? generateTableOrderTypeCached(table, tableName, typeNameMapper, cacheCtx, relationMap, tables) : void 0;
   const filters = generateTableFilterTypeCached(table, tableName, cacheCtx, typeNameMapper, relationMap, tables);
-  const tableFields = generateTableSelectTypeFieldsCached(table, tableName);
+  const tableFields = generateTableSelectTypeFieldsCached(table, tableName, cacheCtx);
   const relationsForTable = relationMap[tableName];
   const relationEntries = relationsForTable ? Object.entries(relationsForTable) : [];
   if (relationsDepthLimit !== void 0 && currentDepth >= relationsDepthLimit) {
@@ -1246,7 +1533,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
       let relType = cacheCtx.objectTypeCache.get(targetTableName);
       if (!relType) {
         const targetTable = tables[targetTableName];
-        const targetTableFields = generateTableSelectTypeFieldsCached(targetTable, targetTableName);
+        const targetTableFields = generateTableSelectTypeFieldsCached(targetTable, targetTableName, cacheCtx);
         let targetContainer = cacheCtx.relationFieldContainers.get(targetTableName);
         if (!targetContainer) {
           targetContainer = { fields: {} };
@@ -2509,7 +2796,7 @@ import {
   count,
   countDistinct,
   eq as eq2,
-  extractExtendedColumnType as extractExtendedColumnType2,
+  extractExtendedColumnType as extractExtendedColumnType3,
   getColumns as getColumns2,
   gt as gt2,
   gte as gte2,
@@ -2553,7 +2840,7 @@ var classifyAggregateColumns = (table, tableName) => {
     if (gqlType instanceof GraphQLList3 || gqlType instanceof GraphQLObjectType3) {
       continue;
     }
-    const { type: dataType, constraint } = extractExtendedColumnType2(column);
+    const { type: dataType, constraint } = extractExtendedColumnType3(column);
     if (dataType === "boolean" || dataType === "array" || dataType === "custom") {
       continue;
     }
@@ -2794,7 +3081,7 @@ var groupableColumns = (table, tableName) => {
     if (groupable[columnName]) {
       continue;
     }
-    const { type: dataType } = extractExtendedColumnType2(column);
+    const { type: dataType } = extractExtendedColumnType3(column);
     if (dataType !== "boolean") {
       continue;
     }
@@ -3047,7 +3334,7 @@ var generateSelectSingle = (db, tableName, tables, relationMap, orderArgs, filte
     args: queryArgs
   };
 };
-var generateInsertArray = (db, _tableName, table, baseType, fieldName) => {
+var generateInsertArray = (db, _tableName, table, baseType, fieldName, txCtx) => {
   const queryArgs = {
     values: {
       type: new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(baseType)))
@@ -3055,14 +3342,16 @@ var generateInsertArray = (db, _tableName, table, baseType, fieldName) => {
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, context, _info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const input = remapFromGraphQLArrayInput(args.values, table);
-        if (!input.length) {
-          throw new GraphQLError5("No values were provided!");
-        }
-        await resolveExecutor(db, context).insert(table).values(input);
-        return { isSuccess: true };
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const input = remapFromGraphQLArrayInput(args.values, table);
+          if (!input.length) {
+            throw new GraphQLError5("No values were provided!");
+          }
+          await executor.insert(table).values(input);
+          return { isSuccess: true };
+        });
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3070,7 +3359,7 @@ var generateInsertArray = (db, _tableName, table, baseType, fieldName) => {
     args: queryArgs
   };
 };
-var generateInsertSingle = (db, _tableName, table, baseType, fieldName) => {
+var generateInsertSingle = (db, _tableName, table, baseType, fieldName, txCtx) => {
   const queryArgs = {
     values: {
       type: new GraphQLNonNull4(baseType)
@@ -3078,11 +3367,13 @@ var generateInsertSingle = (db, _tableName, table, baseType, fieldName) => {
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, context, _info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const input = remapFromGraphQLSingleInput(args.values, table);
-        await resolveExecutor(db, context).insert(table).values(input);
-        return { isSuccess: true };
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const input = remapFromGraphQLSingleInput(args.values, table);
+          await executor.insert(table).values(input);
+          return { isSuccess: true };
+        });
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3090,7 +3381,7 @@ var generateInsertSingle = (db, _tableName, table, baseType, fieldName) => {
     args: queryArgs
   };
 };
-var generateUpsert = (db, table, baseType, onConflictType, fieldName, single) => {
+var generateUpsert = (db, table, baseType, onConflictType, fieldName, single, txCtx) => {
   const queryArgs = {
     values: {
       type: single ? new GraphQLNonNull4(baseType) : new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(baseType)))
@@ -3103,28 +3394,29 @@ var generateUpsert = (db, table, baseType, onConflictType, fieldName, single) =>
   const pkNames = mysqlPrimaryKeyPropNames(table);
   return {
     name: fieldName,
-    resolver: async (_source, args, context, _info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
-        if (!input.length) {
-          throw new GraphQLError5("No values were provided!");
-        }
-        const plan = resolveConflictPlan({
-          table,
-          values: input,
-          onConflict: args.onConflict,
-          pkNames,
-          uniqueSets: [],
-          excludedRef: mysqlValuesColumnRef,
-          withTarget: false
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
+          if (!input.length) {
+            throw new GraphQLError5("No values were provided!");
+          }
+          const plan = resolveConflictPlan({
+            table,
+            values: input,
+            onConflict: args.onConflict,
+            pkNames,
+            uniqueSets: [],
+            excludedRef: mysqlValuesColumnRef,
+            withTarget: false
+          });
+          if (plan.action === "NOTHING") {
+            await executor.insert(table).ignore().values(input);
+          } else {
+            await executor.insert(table).values(input).onDuplicateKeyUpdate({ set: plan.set });
+          }
+          return { isSuccess: true };
         });
-        const executor = resolveExecutor(db, context);
-        if (plan.action === "NOTHING") {
-          await executor.insert(table).ignore().values(input);
-        } else {
-          await executor.insert(table).values(input).onDuplicateKeyUpdate({ set: plan.set });
-        }
-        return { isSuccess: true };
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3132,7 +3424,7 @@ var generateUpsert = (db, table, baseType, onConflictType, fieldName, single) =>
     args: queryArgs
   };
 };
-var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, single, requireWhere, filterCtx) => {
+var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, single, requireWhere, filterCtx, txCtx) => {
   const queryArgs = {
     set: {
       type: new GraphQLNonNull4(setArgs)
@@ -3143,25 +3435,26 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, sing
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, context, _info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const { where, set } = args;
-        const input = remapFromGraphQLSingleInput(set, table);
-        if (!Object.keys(input).length) {
-          throw new GraphQLError5("Unable to update with no values specified!");
-        }
-        const relationCtx = relationFilterCtx(filterCtx, tableName);
-        const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
-        const executor = resolveExecutor(db, context);
-        if (single) {
-          await assertSingleMatch(executor, table, filters, fieldName);
-        }
-        let query = executor.update(table).set(input);
-        if (filters) {
-          query = query.where(filters);
-        }
-        await query;
-        return { isSuccess: true };
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { where, set } = args;
+          const input = remapFromGraphQLSingleInput(set, table);
+          if (!Object.keys(input).length) {
+            throw new GraphQLError5("Unable to update with no values specified!");
+          }
+          const relationCtx = relationFilterCtx(filterCtx, tableName);
+          const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          if (single) {
+            await assertSingleMatch(executor, table, filters, fieldName);
+          }
+          let query = executor.update(table).set(input);
+          if (filters) {
+            query = query.where(filters);
+          }
+          await query;
+          return { isSuccess: true };
+        });
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3169,7 +3462,7 @@ var generateUpdate = (db, tableName, table, setArgs, filterArgs, fieldName, sing
     args: queryArgs
   };
 };
-var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filterCtx) => {
+var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filterCtx, txCtx) => {
   const queryArgs = {
     updates: {
       type: new GraphQLNonNull4(new GraphQLList4(new GraphQLNonNull4(updateManyInput)))
@@ -3177,33 +3470,34 @@ var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filt
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, context, _info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const { updates } = args;
-        if (!updates.length) {
-          throw new GraphQLError5("No updates were provided!");
-        }
-        const entries = updates.map(({ where, set }) => {
-          const input = remapFromGraphQLSingleInput(set, table);
-          if (!Object.keys(input).length) {
-            throw new GraphQLError5("Unable to update with no values specified!");
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { updates } = args;
+          if (!updates.length) {
+            throw new GraphQLError5("No updates were provided!");
           }
-          return {
-            set: input,
-            filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
-          };
-        });
-        const executor = resolveExecutor(db, context);
-        await executor.transaction(async (tx) => {
-          for (const entry of entries) {
-            let query = tx.update(table).set(entry.set);
-            if (entry.filters) {
-              query = query.where(entry.filters);
+          const entries = updates.map(({ where, set }) => {
+            const input = remapFromGraphQLSingleInput(set, table);
+            if (!Object.keys(input).length) {
+              throw new GraphQLError5("Unable to update with no values specified!");
             }
-            await query;
-          }
+            return {
+              set: input,
+              filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+            };
+          });
+          await executor.transaction(async (tx) => {
+            for (const entry of entries) {
+              let query = tx.update(table).set(entry.set);
+              if (entry.filters) {
+                query = query.where(entry.filters);
+              }
+              await query;
+            }
+          });
+          return { isSuccess: true };
         });
-        return { isSuccess: true };
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3211,7 +3505,7 @@ var generateUpdateMany = (db, tableName, table, updateManyInput, fieldName, filt
     args: queryArgs
   };
 };
-var generateDelete = (db, tableName, table, filterArgs, fieldName, single, requireWhere, filterCtx) => {
+var generateDelete = (db, tableName, table, filterArgs, fieldName, single, requireWhere, filterCtx, txCtx) => {
   const queryArgs = {
     where: {
       type: single || requireWhere ? new GraphQLNonNull4(filterArgs) : filterArgs
@@ -3219,21 +3513,22 @@ var generateDelete = (db, tableName, table, filterArgs, fieldName, single, requi
   };
   return {
     name: fieldName,
-    resolver: async (_source, args, context, _info) => {
+    resolver: async (_source, args, context, info) => {
       try {
-        const { where } = args;
-        const relationCtx = relationFilterCtx(filterCtx, tableName);
-        const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
-        const executor = resolveExecutor(db, context);
-        if (single) {
-          await assertSingleMatch(executor, table, filters, fieldName);
-        }
-        let query = executor.delete(table);
-        if (filters) {
-          query = query.where(filters);
-        }
-        await query;
-        return { isSuccess: true };
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { where } = args;
+          const relationCtx = relationFilterCtx(filterCtx, tableName);
+          const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          if (single) {
+            await assertSingleMatch(executor, table, filters, fieldName);
+          }
+          let query = executor.delete(table);
+          if (filters) {
+            query = query.where(filters);
+          }
+          await query;
+          return { isSuccess: true };
+        });
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3253,6 +3548,7 @@ var generateSchemaData = (db, schema, relations, options) => {
       "Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?"
     );
   }
+  registerScalarOverrides(tables, options);
   const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
   attachTargetPrimaryKeys(namedRelations, tables, mysqlPrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
@@ -3264,6 +3560,8 @@ var generateSchemaData = (db, schema, relations, options) => {
     relationFieldContainers: /* @__PURE__ */ new Map(),
     fullyBuiltTables: /* @__PURE__ */ new Set(),
     relationTypeCache: /* @__PURE__ */ new Map(),
+    selectFieldCache: /* @__PURE__ */ new WeakMap(),
+    filterFieldCache: /* @__PURE__ */ new WeakMap(),
     orderTypeCache: /* @__PURE__ */ new WeakMap(),
     filterTypeCache: /* @__PURE__ */ new WeakMap(),
     listRelationFilterCache: /* @__PURE__ */ new Map(),
@@ -3273,6 +3571,7 @@ var generateSchemaData = (db, schema, relations, options) => {
   const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
+  const mutationTxCtx = createMutationTxCtx(options.transactions);
   const gqlSchemaTypes = Object.fromEntries(
     Object.entries(tables).map(([tableName, _table]) => [
       tableName,
@@ -3348,8 +3647,22 @@ var generateSchemaData = (db, schema, relations, options) => {
       typeNameMapper,
       filterCtx
     );
-    const insertArrGenerated = features.insert ? generateInsertArray(db, tableName, schema[tableName], insertInput, createArrayFieldName) : void 0;
-    const insertSingleGenerated = features.insert ? generateInsertSingle(db, tableName, schema[tableName], insertInput, createSingleFieldName) : void 0;
+    const insertArrGenerated = features.insert ? generateInsertArray(
+      db,
+      tableName,
+      schema[tableName],
+      insertInput,
+      createArrayFieldName,
+      mutationTxCtx
+    ) : void 0;
+    const insertSingleGenerated = features.insert ? generateInsertSingle(
+      db,
+      tableName,
+      schema[tableName],
+      insertInput,
+      createSingleFieldName,
+      mutationTxCtx
+    ) : void 0;
     const onConflictInput = features.upsert ? generateOnConflictInput({
       table: schema[tableName],
       typeName,
@@ -3357,8 +3670,24 @@ var generateSchemaData = (db, schema, relations, options) => {
       tableFilters,
       withTarget: false
     }) : void 0;
-    const upsertArrGenerated = onConflictInput ? generateUpsert(db, schema[tableName], insertInput, onConflictInput, upsertArrayFieldName, false) : void 0;
-    const upsertSingleGenerated = onConflictInput ? generateUpsert(db, schema[tableName], insertInput, onConflictInput, upsertSingleFieldName, true) : void 0;
+    const upsertArrGenerated = onConflictInput ? generateUpsert(
+      db,
+      schema[tableName],
+      insertInput,
+      onConflictInput,
+      upsertArrayFieldName,
+      false,
+      mutationTxCtx
+    ) : void 0;
+    const upsertSingleGenerated = onConflictInput ? generateUpsert(
+      db,
+      schema[tableName],
+      insertInput,
+      onConflictInput,
+      upsertSingleFieldName,
+      true,
+      mutationTxCtx
+    ) : void 0;
     const updateGenerated = features.update ? generateUpdate(
       db,
       tableName,
@@ -3368,7 +3697,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       updateFieldName,
       false,
       features.requireWhere,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const updateSingleGenerated = features.update ? generateUpdate(
       db,
@@ -3379,7 +3709,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       updateSingleFieldName,
       true,
       features.requireWhere,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const updateManyInput = features.update && features.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
     const updateManyGenerated = updateManyInput ? generateUpdateMany(
@@ -3388,7 +3719,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       schema[tableName],
       updateManyInput,
       updateManyFieldName,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const deleteGenerated = features.delete ? generateDelete(
       db,
@@ -3398,7 +3730,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       deleteFieldName,
       false,
       features.requireWhere,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const deleteSingleGenerated = features.delete ? generateDelete(
       db,
@@ -3408,7 +3741,8 @@ var generateSchemaData = (db, schema, relations, options) => {
       deleteSingleFieldName,
       true,
       features.requireWhere,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const aggregateGenerated = features.aggregates ? generateAggregate(
@@ -3501,6 +3835,11 @@ var generateSchemaData = (db, schema, relations, options) => {
       inputs[havingInput.name] = havingInput;
     }
   }
+  if (mutationTxCtx) {
+    for (const name of Object.keys(mutations)) {
+      mutationTxCtx.fieldNames.add(name);
+    }
+  }
   const fieldResolvers = {};
   for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
     const relResolvers = {};
@@ -3708,7 +4047,7 @@ var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filt
   };
 };
 var pgPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig2);
-var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
+var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx) => {
   const queryArgs = {
     values: {
       type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(baseType)))
@@ -3719,31 +4058,32 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const input = remapFromGraphQLArrayInput(args.values, table);
-        if (!input.length) {
-          throw new GraphQLError6("No values were provided!");
-        }
-        const parsedInfo = parseResolveInfo3(info, {
-          deep: true
-        });
-        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-          relationMap,
-          tables,
-          tableName,
-          typeName,
-          typeNameMapper,
-          table,
-          pkNames,
-          parsedInfo
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const input = remapFromGraphQLArrayInput(args.values, table);
+          if (!input.length) {
+            throw new GraphQLError6("No values were provided!");
+          }
+          const parsedInfo = parseResolveInfo3(info, {
+            deep: true
+          });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          let query = executor.insert(table).values(input).returning(columns);
+          if (conflictDoNothing) {
+            query = query.onConflictDoNothing();
+          }
+          const result = await query;
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+          return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
         });
-        const executor = resolveExecutor(db, context);
-        let query = executor.insert(table).values(input).returning(columns);
-        if (conflictDoNothing) {
-          query = query.onConflictDoNothing();
-        }
-        const result = await query;
-        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-        return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3751,7 +4091,7 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
     args: queryArgs
   };
 };
-var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
+var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx) => {
   const queryArgs = {
     values: {
       type: new GraphQLNonNull5(baseType)
@@ -3762,31 +4102,32 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const input = remapFromGraphQLSingleInput(args.values, table);
-        const parsedInfo = parseResolveInfo3(info, {
-          deep: true
-        });
-        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-          relationMap,
-          tables,
-          tableName,
-          typeName,
-          typeNameMapper,
-          table,
-          pkNames,
-          parsedInfo
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const input = remapFromGraphQLSingleInput(args.values, table);
+          const parsedInfo = parseResolveInfo3(info, {
+            deep: true
+          });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          let query = executor.insert(table).values(input).returning(columns);
+          if (conflictDoNothing) {
+            query = query.onConflictDoNothing();
+          }
+          const result = await query;
+          if (!result[0]) {
+            return void 0;
+          }
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+          return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
         });
-        const executor = resolveExecutor(db, context);
-        let query = executor.insert(table).values(input).returning(columns);
-        if (conflictDoNothing) {
-          query = query.onConflictDoNothing();
-        }
-        const result = await query;
-        if (!result[0]) {
-          return void 0;
-        }
-        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-        return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3794,7 +4135,7 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
     args: queryArgs
   };
 };
-var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx) => {
+var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx) => {
   const queryArgs = {
     values: {
       type: single ? new GraphQLNonNull5(baseType) : new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(baseType)))
@@ -3809,40 +4150,41 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
-        if (!input.length) {
-          throw new GraphQLError6("No values were provided!");
-        }
-        const parsedInfo = parseResolveInfo3(info, { deep: true });
-        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-          relationMap,
-          tables,
-          tableName,
-          typeName,
-          typeNameMapper,
-          table,
-          pkNames,
-          parsedInfo
-        });
-        const plan = resolveConflictPlan({
-          table,
-          values: input,
-          onConflict: args.onConflict,
-          pkNames,
-          uniqueSets,
-          excludedRef: excludedColumnRef,
-          withTarget: true,
-          buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
+          if (!input.length) {
+            throw new GraphQLError6("No values were provided!");
+          }
+          const parsedInfo = parseResolveInfo3(info, { deep: true });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          const plan = resolveConflictPlan({
+            table,
+            values: input,
+            onConflict: args.onConflict,
+            pkNames,
+            uniqueSets,
+            excludedRef: excludedColumnRef,
+            withTarget: true,
+            buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
+          });
+          let query = executor.insert(table).values(input).returning(columns);
+          query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
+          const result = await query;
+          if (single && !result[0]) {
+            return void 0;
+          }
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+          return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
         });
-        const executor = resolveExecutor(db, context);
-        let query = executor.insert(table).values(input).returning(columns);
-        query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
-        const result = await query;
-        if (single && !result[0]) {
-          return void 0;
-        }
-        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-        return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3850,7 +4192,7 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
     args: queryArgs
   };
 };
-var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx) => {
+var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx) => {
   const queryArgs = {
     set: {
       type: new GraphQLNonNull5(setArgs)
@@ -3861,47 +4203,48 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
   };
   const pkNames = pgPrimaryKeyPropNames(table);
   return {
-    name: fieldName,
-    resolver: async (_source, args, context, info) => {
-      try {
-        const { where, set } = args;
-        const parsedInfo = parseResolveInfo3(info, {
-          deep: true
-        });
-        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-          relationMap,
-          tables,
-          tableName,
-          typeName,
-          typeNameMapper,
-          table,
-          pkNames,
-          parsedInfo
+    name: fieldName,
+    resolver: async (_source, args, context, info) => {
+      try {
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { where, set } = args;
+          const parsedInfo = parseResolveInfo3(info, {
+            deep: true
+          });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          const input = remapFromGraphQLSingleInput(set, table);
+          if (!Object.keys(input).length) {
+            throw new GraphQLError6("Unable to update with no values specified!");
+          }
+          const relationCtx = relationFilterCtx(filterCtx, tableName);
+          const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          if (single) {
+            await assertSingleMatch(executor, table, filters, fieldName);
+          }
+          let query = executor.update(table).set(input);
+          if (filters) {
+            query = query.where(filters);
+          }
+          query = query.returning(columns);
+          const result = await query;
+          if (single && result.length > 1) {
+            throw new GraphQLError6(`${fieldName}: 'where' matched more than one row!`);
+          }
+          if (single && !result[0]) {
+            return void 0;
+          }
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+          return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
         });
-        const input = remapFromGraphQLSingleInput(set, table);
-        if (!Object.keys(input).length) {
-          throw new GraphQLError6("Unable to update with no values specified!");
-        }
-        const relationCtx = relationFilterCtx(filterCtx, tableName);
-        const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
-        const executor = resolveExecutor(db, context);
-        if (single) {
-          await assertSingleMatch(executor, table, filters, fieldName);
-        }
-        let query = executor.update(table).set(input);
-        if (filters) {
-          query = query.where(filters);
-        }
-        query = query.returning(columns);
-        const result = await query;
-        if (single && result.length > 1) {
-          throw new GraphQLError6(`${fieldName}: 'where' matched more than one row!`);
-        }
-        if (single && !result[0]) {
-          return void 0;
-        }
-        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-        return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3909,7 +4252,7 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
-var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx) => {
+var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx) => {
   const queryArgs = {
     updates: {
       type: new GraphQLNonNull5(new GraphQLList5(new GraphQLNonNull5(updateManyInput)))
@@ -3920,60 +4263,61 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const { updates } = args;
-        if (!updates.length) {
-          throw new GraphQLError6("No updates were provided!");
-        }
-        const parsedInfo = parseResolveInfo3(info, {
-          deep: true
-        });
-        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-          relationMap,
-          tables,
-          tableName,
-          typeName,
-          typeNameMapper,
-          table,
-          pkNames,
-          parsedInfo
-        });
-        const entries = updates.map(({ where, set }) => {
-          const input = remapFromGraphQLSingleInput(set, table);
-          if (!Object.keys(input).length) {
-            throw new GraphQLError6("Unable to update with no values specified!");
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { updates } = args;
+          if (!updates.length) {
+            throw new GraphQLError6("No updates were provided!");
           }
-          return {
-            set: input,
-            filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
-          };
-        });
-        const executor = resolveExecutor(db, context);
-        const perEntry = await executor.transaction(async (tx) => {
-          const results = [];
-          for (const entry of entries) {
-            let query = tx.update(table).set(entry.set);
-            if (entry.filters) {
-              query = query.where(entry.filters);
+          const parsedInfo = parseResolveInfo3(info, {
+            deep: true
+          });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          const entries = updates.map(({ where, set }) => {
+            const input = remapFromGraphQLSingleInput(set, table);
+            if (!Object.keys(input).length) {
+              throw new GraphQLError6("Unable to update with no values specified!");
+            }
+            return {
+              set: input,
+              filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+            };
+          });
+          const perEntry = await executor.transaction(async (tx) => {
+            const results = [];
+            for (const entry of entries) {
+              let query = tx.update(table).set(entry.set);
+              if (entry.filters) {
+                query = query.where(entry.filters);
+              }
+              results.push(await query.returning(columns));
+            }
+            return results;
+          });
+          const flatRows = perEntry.flat();
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, flatRows, pkNames, withParams) : flatRows;
+          const output = [];
+          let offset = 0;
+          for (const rows of perEntry) {
+            if (!rows.length) {
+              output.push(null);
+              continue;
+            }
+            for (let i = 0; i < rows.length; i++) {
+              output.push(remapToGraphQLSingleOutput(enriched[offset + i], tableName, table, relationMap));
             }
-            results.push(await query.returning(columns));
+            offset += rows.length;
           }
-          return results;
+          return output;
         });
-        const flatRows = perEntry.flat();
-        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, flatRows, pkNames, withParams) : flatRows;
-        const output = [];
-        let offset = 0;
-        for (const rows of perEntry) {
-          if (!rows.length) {
-            output.push(null);
-            continue;
-          }
-          for (let i = 0; i < rows.length; i++) {
-            output.push(remapToGraphQLSingleOutput(enriched[offset + i], tableName, table, relationMap));
-          }
-          offset += rows.length;
-        }
-        return output;
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -3981,7 +4325,7 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
     args: queryArgs
   };
 };
-var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx) => {
+var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx) => {
   const queryArgs = {
     where: {
       type: single || requireWhere ? new GraphQLNonNull5(filterArgs) : filterArgs
@@ -3991,34 +4335,35 @@ var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, si
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const { where } = args;
-        const parsedInfo = parseResolveInfo3(info, {
-          deep: true
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { where } = args;
+          const parsedInfo = parseResolveInfo3(info, {
+            deep: true
+          });
+          const columns = extractSelectedColumnsFromTreeSQLFormat(
+            parsedInfo.fieldsByTypeName[typeName],
+            table,
+            selectionCtx
+          );
+          const relationCtx = relationFilterCtx(filterCtx, tableName);
+          const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          if (single) {
+            await assertSingleMatch(executor, table, filters, fieldName);
+          }
+          let query = executor.delete(table);
+          if (filters) {
+            query = query.where(filters);
+          }
+          query = query.returning(columns);
+          const result = await query;
+          if (single && result.length > 1) {
+            throw new GraphQLError6(`${fieldName}: 'where' matched more than one row!`);
+          }
+          if (single) {
+            return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
+          }
+          return remapToGraphQLArrayOutput(result, tableName, table);
         });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table,
-          selectionCtx
-        );
-        const relationCtx = relationFilterCtx(filterCtx, tableName);
-        const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
-        const executor = resolveExecutor(db, context);
-        if (single) {
-          await assertSingleMatch(executor, table, filters, fieldName);
-        }
-        let query = executor.delete(table);
-        if (filters) {
-          query = query.where(filters);
-        }
-        query = query.returning(columns);
-        const result = await query;
-        if (single && result.length > 1) {
-          throw new GraphQLError6(`${fieldName}: 'where' matched more than one row!`);
-        }
-        if (single) {
-          return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
-        }
-        return remapToGraphQLArrayOutput(result, tableName, table);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -4045,6 +4390,7 @@ function generateSchemaData2(db, schema, relations, options) {
       "Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?"
     );
   }
+  registerScalarOverrides(tables, options);
   const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
   attachTargetPrimaryKeys(namedRelations, tables, pgPrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
@@ -4056,6 +4402,8 @@ function generateSchemaData2(db, schema, relations, options) {
     relationFieldContainers: /* @__PURE__ */ new Map(),
     fullyBuiltTables: /* @__PURE__ */ new Set(),
     relationTypeCache: /* @__PURE__ */ new Map(),
+    selectFieldCache: /* @__PURE__ */ new WeakMap(),
+    filterFieldCache: /* @__PURE__ */ new WeakMap(),
     orderTypeCache: /* @__PURE__ */ new WeakMap(),
     filterTypeCache: /* @__PURE__ */ new WeakMap(),
     listRelationFilterCache: /* @__PURE__ */ new Map(),
@@ -4065,6 +4413,7 @@ function generateSchemaData2(db, schema, relations, options) {
   const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
+  const mutationTxCtx = createMutationTxCtx(options.transactions);
   const gqlSchemaTypes = Object.fromEntries(
     Object.entries(tables).map(([tableName, _table]) => [
       tableName,
@@ -4139,7 +4488,8 @@ function generateSchemaData2(db, schema, relations, options) {
       createArrayFieldName,
       typeName,
       typeNameMapper,
-      conflictDoNothing
+      conflictDoNothing,
+      mutationTxCtx
     ) : void 0;
     const insertSingleGenerated = features.insert ? generateInsertSingle2(
       db,
@@ -4151,7 +4501,8 @@ function generateSchemaData2(db, schema, relations, options) {
       createSingleFieldName,
       typeName,
       typeNameMapper,
-      conflictDoNothing
+      conflictDoNothing,
+      mutationTxCtx
     ) : void 0;
     const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], getTableConfig2) : [];
     const onConflictInput = features.upsert ? generateOnConflictInput({
@@ -4174,7 +4525,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeName,
       false,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const upsertSingleGenerated = onConflictInput ? generateUpsert2(
       db,
@@ -4189,7 +4541,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeName,
       true,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const updateGenerated = features.update ? generateUpdate2(
       db,
@@ -4204,7 +4557,8 @@ function generateSchemaData2(db, schema, relations, options) {
       false,
       features.requireWhere,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const updateSingleGenerated = features.update ? generateUpdate2(
       db,
@@ -4219,7 +4573,8 @@ function generateSchemaData2(db, schema, relations, options) {
       true,
       features.requireWhere,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const updateManyInput = features.update && features.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
     const updateManyGenerated = updateManyInput ? generateUpdateMany2(
@@ -4232,7 +4587,8 @@ function generateSchemaData2(db, schema, relations, options) {
       updateManyFieldName,
       typeName,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const deleteGenerated = features.delete ? generateDelete2(
       db,
@@ -4244,7 +4600,8 @@ function generateSchemaData2(db, schema, relations, options) {
       false,
       features.requireWhere,
       filterCtx,
-      { tableName, relationMap: namedRelations, tables }
+      { tableName, relationMap: namedRelations, tables },
+      mutationTxCtx
     ) : void 0;
     const deleteSingleGenerated = features.delete ? generateDelete2(
       db,
@@ -4256,7 +4613,8 @@ function generateSchemaData2(db, schema, relations, options) {
       true,
       features.requireWhere,
       filterCtx,
-      { tableName, relationMap: namedRelations, tables }
+      { tableName, relationMap: namedRelations, tables },
+      mutationTxCtx
     ) : void 0;
     const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const aggregateGenerated = features.aggregates ? generateAggregate(
@@ -4395,6 +4753,11 @@ function generateSchemaData2(db, schema, relations, options) {
       inputs[havingInput.name] = havingInput;
     }
   }
+  if (mutationTxCtx) {
+    for (const name of Object.keys(mutations)) {
+      mutationTxCtx.fieldNames.add(name);
+    }
+  }
   const fieldResolvers = {};
   for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
     const relResolvers = {};
@@ -4504,7 +4867,7 @@ var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filt
   };
 };
 var sqlitePrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig3);
-var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
+var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx) => {
   const queryArgs = {
     values: {
       type: new GraphQLNonNull6(new GraphQLList6(new GraphQLNonNull6(baseType)))
@@ -4515,31 +4878,32 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const input = remapFromGraphQLArrayInput(args.values, table);
-        if (!input.length) {
-          throw new GraphQLError7("No values were provided!");
-        }
-        const parsedInfo = parseResolveInfo4(info, {
-          deep: true
-        });
-        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-          relationMap,
-          tables,
-          tableName,
-          typeName,
-          typeNameMapper,
-          table,
-          pkNames,
-          parsedInfo
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const input = remapFromGraphQLArrayInput(args.values, table);
+          if (!input.length) {
+            throw new GraphQLError7("No values were provided!");
+          }
+          const parsedInfo = parseResolveInfo4(info, {
+            deep: true
+          });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          let query = executor.insert(table).values(input).returning(columns);
+          if (conflictDoNothing) {
+            query = query.onConflictDoNothing();
+          }
+          const result = await query;
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+          return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
         });
-        const executor = resolveExecutor(db, context);
-        let query = executor.insert(table).values(input).returning(columns);
-        if (conflictDoNothing) {
-          query = query.onConflictDoNothing();
-        }
-        const result = await query;
-        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-        return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -4547,7 +4911,7 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
     args: queryArgs
   };
 };
-var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false) => {
+var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx) => {
   const queryArgs = {
     values: {
       type: new GraphQLNonNull6(baseType)
@@ -4558,31 +4922,32 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const input = remapFromGraphQLSingleInput(args.values, table);
-        const parsedInfo = parseResolveInfo4(info, {
-          deep: true
-        });
-        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-          relationMap,
-          tables,
-          tableName,
-          typeName,
-          typeNameMapper,
-          table,
-          pkNames,
-          parsedInfo
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const input = remapFromGraphQLSingleInput(args.values, table);
+          const parsedInfo = parseResolveInfo4(info, {
+            deep: true
+          });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          let query = executor.insert(table).values(input).returning(columns);
+          if (conflictDoNothing) {
+            query = query.onConflictDoNothing();
+          }
+          const result = await query;
+          if (!result[0]) {
+            return void 0;
+          }
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+          return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
         });
-        const executor = resolveExecutor(db, context);
-        let query = executor.insert(table).values(input).returning(columns);
-        if (conflictDoNothing) {
-          query = query.onConflictDoNothing();
-        }
-        const result = await query;
-        if (!result[0]) {
-          return void 0;
-        }
-        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-        return remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -4590,7 +4955,7 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
     args: queryArgs
   };
 };
-var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx) => {
+var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx) => {
   const queryArgs = {
     values: {
       type: single ? new GraphQLNonNull6(baseType) : new GraphQLNonNull6(new GraphQLList6(new GraphQLNonNull6(baseType)))
@@ -4605,40 +4970,41 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
-        if (!input.length) {
-          throw new GraphQLError7("No values were provided!");
-        }
-        const parsedInfo = parseResolveInfo4(info, { deep: true });
-        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-          relationMap,
-          tables,
-          tableName,
-          typeName,
-          typeNameMapper,
-          table,
-          pkNames,
-          parsedInfo
-        });
-        const plan = resolveConflictPlan({
-          table,
-          values: input,
-          onConflict: args.onConflict,
-          pkNames,
-          uniqueSets,
-          excludedRef: excludedColumnRef,
-          withTarget: true,
-          buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const input = single ? [remapFromGraphQLSingleInput(args.values, table)] : remapFromGraphQLArrayInput(args.values, table);
+          if (!input.length) {
+            throw new GraphQLError7("No values were provided!");
+          }
+          const parsedInfo = parseResolveInfo4(info, { deep: true });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          const plan = resolveConflictPlan({
+            table,
+            values: input,
+            onConflict: args.onConflict,
+            pkNames,
+            uniqueSets,
+            excludedRef: excludedColumnRef,
+            withTarget: true,
+            buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
+          });
+          let query = executor.insert(table).values(input).returning(columns);
+          query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
+          const result = await query;
+          if (single && !result[0]) {
+            return void 0;
+          }
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+          return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
         });
-        const executor = resolveExecutor(db, context);
-        let query = executor.insert(table).values(input).returning(columns);
-        query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
-        const result = await query;
-        if (single && !result[0]) {
-          return void 0;
-        }
-        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-        return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -4646,7 +5012,7 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
     args: queryArgs
   };
 };
-var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx) => {
+var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx) => {
   const queryArgs = {
     set: {
       type: new GraphQLNonNull6(setArgs)
@@ -4660,44 +5026,45 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const { where, set } = args;
-        const parsedInfo = parseResolveInfo4(info, {
-          deep: true
-        });
-        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-          relationMap,
-          tables,
-          tableName,
-          typeName,
-          typeNameMapper,
-          table,
-          pkNames,
-          parsedInfo
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { where, set } = args;
+          const parsedInfo = parseResolveInfo4(info, {
+            deep: true
+          });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          const input = remapFromGraphQLSingleInput(set, table);
+          if (!Object.keys(input).length) {
+            throw new GraphQLError7("Unable to update with no values specified!");
+          }
+          const relationCtx = relationFilterCtx(filterCtx, tableName);
+          const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          if (single) {
+            await assertSingleMatch(executor, table, filters, fieldName);
+          }
+          let query = executor.update(table).set(input);
+          if (filters) {
+            query = query.where(filters);
+          }
+          query = query.returning(columns);
+          const result = await query;
+          if (single && result.length > 1) {
+            throw new GraphQLError7(`${fieldName}: 'where' matched more than one row!`);
+          }
+          if (single && !result[0]) {
+            return void 0;
+          }
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
+          return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
         });
-        const input = remapFromGraphQLSingleInput(set, table);
-        if (!Object.keys(input).length) {
-          throw new GraphQLError7("Unable to update with no values specified!");
-        }
-        const relationCtx = relationFilterCtx(filterCtx, tableName);
-        const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
-        const executor = resolveExecutor(db, context);
-        if (single) {
-          await assertSingleMatch(executor, table, filters, fieldName);
-        }
-        let query = executor.update(table).set(input);
-        if (filters) {
-          query = query.where(filters);
-        }
-        query = query.returning(columns);
-        const result = await query;
-        if (single && result.length > 1) {
-          throw new GraphQLError7(`${fieldName}: 'where' matched more than one row!`);
-        }
-        if (single && !result[0]) {
-          return void 0;
-        }
-        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
-        return single ? remapToGraphQLSingleOutput(enriched[0], tableName, table, relationMap) : remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -4705,7 +5072,7 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
-var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx) => {
+var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx) => {
   const queryArgs = {
     updates: {
       type: new GraphQLNonNull6(new GraphQLList6(new GraphQLNonNull6(updateManyInput)))
@@ -4716,73 +5083,74 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const { updates } = args;
-        if (!updates.length) {
-          throw new GraphQLError7("No updates were provided!");
-        }
-        const parsedInfo = parseResolveInfo4(info, {
-          deep: true
-        });
-        const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
-          relationMap,
-          tables,
-          tableName,
-          typeName,
-          typeNameMapper,
-          table,
-          pkNames,
-          parsedInfo
-        });
-        const entries = updates.map(({ where, set }) => {
-          const input = remapFromGraphQLSingleInput(set, table);
-          if (!Object.keys(input).length) {
-            throw new GraphQLError7("Unable to update with no values specified!");
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { updates } = args;
+          if (!updates.length) {
+            throw new GraphQLError7("No updates were provided!");
           }
-          return {
-            set: input,
-            filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+          const parsedInfo = parseResolveInfo4(info, {
+            deep: true
+          });
+          const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
+            relationMap,
+            tables,
+            tableName,
+            typeName,
+            typeNameMapper,
+            table,
+            pkNames,
+            parsedInfo
+          });
+          const entries = updates.map(({ where, set }) => {
+            const input = remapFromGraphQLSingleInput(set, table);
+            if (!Object.keys(input).length) {
+              throw new GraphQLError7("Unable to update with no values specified!");
+            }
+            return {
+              set: input,
+              filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
+            };
+          });
+          const runEntry = (tx, entry) => {
+            let query = tx.update(table).set(entry.set);
+            if (entry.filters) {
+              query = query.where(entry.filters);
+            }
+            return query.returning(columns).all();
           };
-        });
-        const runEntry = (tx, entry) => {
-          let query = tx.update(table).set(entry.set);
-          if (entry.filters) {
-            query = query.where(entry.filters);
-          }
-          return query.returning(columns).all();
-        };
-        const executor = resolveExecutor(db, context);
-        const perEntry = await executor.transaction((tx) => {
-          const first = runEntry(tx, entries[0]);
-          if (typeof first?.then === "function") {
-            return (async () => {
-              const results2 = [await first];
-              for (let i = 1; i < entries.length; i++) {
-                results2.push(await runEntry(tx, entries[i]));
-              }
-              return results2;
-            })();
-          }
-          const results = [first];
-          for (let i = 1; i < entries.length; i++) {
-            results.push(runEntry(tx, entries[i]));
+          const perEntry = await executor.transaction((tx) => {
+            const first = runEntry(tx, entries[0]);
+            if (typeof first?.then === "function") {
+              return (async () => {
+                const results2 = [await first];
+                for (let i = 1; i < entries.length; i++) {
+                  results2.push(await runEntry(tx, entries[i]));
+                }
+                return results2;
+              })();
+            }
+            const results = [first];
+            for (let i = 1; i < entries.length; i++) {
+              results.push(runEntry(tx, entries[i]));
+            }
+            return results;
+          });
+          const flatRows = perEntry.flat();
+          const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, flatRows, pkNames, withParams) : flatRows;
+          const output = [];
+          let offset = 0;
+          for (const rows of perEntry) {
+            if (!rows.length) {
+              output.push(null);
+              continue;
+            }
+            for (let i = 0; i < rows.length; i++) {
+              output.push(remapToGraphQLSingleOutput(enriched[offset + i], tableName, table, relationMap));
+            }
+            offset += rows.length;
           }
-          return results;
+          return output;
         });
-        const flatRows = perEntry.flat();
-        const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, flatRows, pkNames, withParams) : flatRows;
-        const output = [];
-        let offset = 0;
-        for (const rows of perEntry) {
-          if (!rows.length) {
-            output.push(null);
-            continue;
-          }
-          for (let i = 0; i < rows.length; i++) {
-            output.push(remapToGraphQLSingleOutput(enriched[offset + i], tableName, table, relationMap));
-          }
-          offset += rows.length;
-        }
-        return output;
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -4790,7 +5158,7 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
     args: queryArgs
   };
 };
-var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx) => {
+var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx) => {
   const queryArgs = {
     where: {
       type: single || requireWhere ? new GraphQLNonNull6(filterArgs) : filterArgs
@@ -4800,34 +5168,35 @@ var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, si
     name: fieldName,
     resolver: async (_source, args, context, info) => {
       try {
-        const { where } = args;
-        const parsedInfo = parseResolveInfo4(info, {
-          deep: true
+        return await runMutation(db, context, info, txCtx, async (executor) => {
+          const { where } = args;
+          const parsedInfo = parseResolveInfo4(info, {
+            deep: true
+          });
+          const columns = extractSelectedColumnsFromTreeSQLFormat(
+            parsedInfo.fieldsByTypeName[typeName],
+            table,
+            selectionCtx
+          );
+          const relationCtx = relationFilterCtx(filterCtx, tableName);
+          const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
+          if (single) {
+            await assertSingleMatch(executor, table, filters, fieldName);
+          }
+          let query = executor.delete(table);
+          if (filters) {
+            query = query.where(filters);
+          }
+          query = query.returning(columns);
+          const result = await query;
+          if (single && result.length > 1) {
+            throw new GraphQLError7(`${fieldName}: 'where' matched more than one row!`);
+          }
+          if (single) {
+            return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
+          }
+          return remapToGraphQLArrayOutput(result, tableName, table);
         });
-        const columns = extractSelectedColumnsFromTreeSQLFormat(
-          parsedInfo.fieldsByTypeName[typeName],
-          table,
-          selectionCtx
-        );
-        const relationCtx = relationFilterCtx(filterCtx, tableName);
-        const filters = single || requireWhere ? extractRequiredFilters(table, tableName, where, fieldName, relationCtx) : where ? extractFilters(table, tableName, where, relationCtx) : void 0;
-        const executor = resolveExecutor(db, context);
-        if (single) {
-          await assertSingleMatch(executor, table, filters, fieldName);
-        }
-        let query = executor.delete(table);
-        if (filters) {
-          query = query.where(filters);
-        }
-        query = query.returning(columns);
-        const result = await query;
-        if (single && result.length > 1) {
-          throw new GraphQLError7(`${fieldName}: 'where' matched more than one row!`);
-        }
-        if (single) {
-          return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
-        }
-        return remapToGraphQLArrayOutput(result, tableName, table);
       } catch (e) {
         throw toGraphQLError(e);
       }
@@ -4855,6 +5224,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       "Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?"
     );
   }
+  registerScalarOverrides(tables, options);
   const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
   attachTargetPrimaryKeys(namedRelations, tables, sqlitePrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
@@ -4866,6 +5236,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     relationFieldContainers: /* @__PURE__ */ new Map(),
     fullyBuiltTables: /* @__PURE__ */ new Set(),
     relationTypeCache: /* @__PURE__ */ new Map(),
+    selectFieldCache: /* @__PURE__ */ new WeakMap(),
+    filterFieldCache: /* @__PURE__ */ new WeakMap(),
     orderTypeCache: /* @__PURE__ */ new WeakMap(),
     filterTypeCache: /* @__PURE__ */ new WeakMap(),
     listRelationFilterCache: /* @__PURE__ */ new Map(),
@@ -4875,6 +5247,12 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
+  if (options.transactions && db.resultKind === "sync") {
+    throw new Error(
+      "Drizzle-GraphQL Error: transactions: 'auto' requires an asynchronous SQLite driver (e.g. libsql). Synchronous drivers cannot hold a transaction open across resolvers."
+    );
+  }
+  const mutationTxCtx = createMutationTxCtx(options.transactions);
   const gqlSchemaTypes = Object.fromEntries(
     Object.entries(tables).map(([tableName, _table]) => [
       tableName,
@@ -4949,7 +5327,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       createArrayFieldName,
       typeName,
       typeNameMapper,
-      conflictDoNothing
+      conflictDoNothing,
+      mutationTxCtx
     ) : void 0;
     const insertSingleGenerated = features.insert ? generateInsertSingle3(
       db,
@@ -4961,7 +5340,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       createSingleFieldName,
       typeName,
       typeNameMapper,
-      conflictDoNothing
+      conflictDoNothing,
+      mutationTxCtx
     ) : void 0;
     const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], getTableConfig3) : [];
     const onConflictInput = features.upsert ? generateOnConflictInput({
@@ -4984,7 +5364,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeName,
       false,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const upsertSingleGenerated = onConflictInput ? generateUpsert3(
       db,
@@ -4999,7 +5380,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeName,
       true,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const updateGenerated = features.update ? generateUpdate3(
       db,
@@ -5014,7 +5396,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       false,
       features.requireWhere,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const updateSingleGenerated = features.update ? generateUpdate3(
       db,
@@ -5029,7 +5412,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       true,
       features.requireWhere,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const updateManyInput = features.update && features.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
     const updateManyGenerated = updateManyInput ? generateUpdateMany3(
@@ -5042,7 +5426,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       updateManyFieldName,
       typeName,
       typeNameMapper,
-      filterCtx
+      filterCtx,
+      mutationTxCtx
     ) : void 0;
     const deleteGenerated = features.delete ? generateDelete3(
       db,
@@ -5054,7 +5439,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       false,
       features.requireWhere,
       filterCtx,
-      { tableName, relationMap: namedRelations, tables }
+      { tableName, relationMap: namedRelations, tables },
+      mutationTxCtx
     ) : void 0;
     const deleteSingleGenerated = features.delete ? generateDelete3(
       db,
@@ -5066,7 +5452,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       true,
       features.requireWhere,
       filterCtx,
-      { tableName, relationMap: namedRelations, tables }
+      { tableName, relationMap: namedRelations, tables },
+      mutationTxCtx
     ) : void 0;
     const aggregateType = features.aggregates ? generateAggregateTypes(schema[tableName], tableName, typeName, cacheCtx) : void 0;
     const aggregateGenerated = features.aggregates ? generateAggregate(
@@ -5205,6 +5592,11 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       inputs[havingInput.name] = havingInput;
     }
   }
+  if (mutationTxCtx) {
+    for (const name of Object.keys(mutations)) {
+      mutationTxCtx.fieldNames.add(name);
+    }
+  }
   const fieldResolvers = {};
   for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
     const relResolvers = {};
@@ -5261,6 +5653,8 @@ var buildSchema = (db, config) => {
     defaultListSize: (complexityConfig === true ? void 0 : complexityConfig.defaultListSize) ?? 10,
     aggregateCost: (complexityConfig === true ? void 0 : complexityConfig.aggregateCost) ?? 10
   };
+  const transactionsOpt = config?.transactions;
+  const transactions = transactionsOpt === void 0 || transactionsOpt === "none" ? void 0 : { timeoutMs: (transactionsOpt === "auto" ? void 0 : transactionsOpt.timeoutMs) ?? 3e4 };
   const eagerOpt = config?.eagerLoadRelations;
   const shouldEagerLoad = eagerOpt === void 0 || eagerOpt === true ? () => true : eagerOpt === false ? () => false : eagerOpt;
   if (!typeNameMapper && suffixes.list === suffixes.single) {
@@ -5288,7 +5682,10 @@ var buildSchema = (db, config) => {
     typeNameMapper,
     shouldEagerLoad,
     features,
-    complexity
+    complexity,
+    scalars: config?.scalars,
+    mapColumnType: config?.mapColumnType,
+    transactions
   };
   let generatorOutput;
   if (is7(db, MySqlDatabase)) {