@vantreeseba/drizzle-graphql 5.5.0 → 6.0.0

package/dist/index.cjs

@@ -45,11 +45,11 @@ __export(index_exports, {
   extractRelationJoinColumns: () => extractRelationJoinColumns
 });
 module.exports = __toCommonJS(index_exports);
-var import_drizzle_orm8 = require("drizzle-orm");
+var import_drizzle_orm9 = require("drizzle-orm");
 var import_mysql_core3 = require("drizzle-orm/mysql-core");
 var import_pg_core3 = require("drizzle-orm/pg-core");
 var import_sqlite_core3 = require("drizzle-orm/sqlite-core");
-var import_graphql9 = require("graphql");
+var import_graphql10 = require("graphql");
 
 // src/util/builders/common.ts
 var import_drizzle_orm3 = require("drizzle-orm");
@@ -107,8 +107,293 @@ 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
+var import_drizzle_orm2 = require("drizzle-orm");
+var import_graphql3 = require("graphql");
+
+// src/util/type-converter/index.ts
 var import_drizzle_orm = require("drizzle-orm");
+var import_mysql_core = require("drizzle-orm/mysql-core");
+var import_pg_core = require("drizzle-orm/pg-core");
+var import_sqlite_core = require("drizzle-orm/sqlite-core");
+var import_graphql2 = require("graphql");
+
+// src/util/scalars/index.ts
 var import_graphql = require("graphql");
+var import_graphql_scalars = require("graphql-scalars");
+var asDecimalString = (value) => {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number") {
+    if (!Number.isInteger(value)) {
+      throw new import_graphql.GraphQLError(`BigInt cannot represent non-integer value: ${value}`);
+    }
+    if (!Number.isSafeInteger(value)) {
+      throw new import_graphql.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 import_graphql.GraphQLError(`BigInt cannot represent non-integer value: "${value}"`);
+    }
+    return value;
+  }
+  throw new import_graphql.GraphQLError(`BigInt cannot represent value: ${JSON.stringify(value)}`);
+};
+var GraphQLBigIntString = new import_graphql.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 !== import_graphql.Kind.STRING && ast.kind !== import_graphql.Kind.INT) {
+      throw new import_graphql.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 import_graphql.GraphQLError(`Decimal cannot represent non-finite value: ${value}`);
+    }
+    return String(value);
+  }
+  if (typeof value === "string") {
+    if (!numericStringPattern.test(value)) {
+      throw new import_graphql.GraphQLError(`Decimal cannot represent non-numeric value: "${value}"`);
+    }
+    return value;
+  }
+  throw new import_graphql.GraphQLError(`Decimal cannot represent value: ${JSON.stringify(value)}`);
+};
+var GraphQLDecimalString = new import_graphql.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 !== import_graphql.Kind.STRING && ast.kind !== import_graphql.Kind.INT && ast.kind !== import_graphql.Kind.FLOAT) {
+      throw new import_graphql.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 declaredEnum = (column) => {
+  const declared = column.enum;
+  return typeof declared?.enumName === "string" ? { enumName: declared.enumName, schema: typeof declared.schema === "string" ? declared.schema : void 0 } : void 0;
+};
+var pascalize = (input) => input.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part) => capitalize(part)).join("");
+var enumValuesKey = (values) => JSON.stringify(values);
+var enumNamesInUse = /* @__PURE__ */ new Map();
+var enumNameMapper;
+var registerEnumConfig = (config) => {
+  enumNameMapper = config.enumNameMapper;
+  enumNamesInUse = /* @__PURE__ */ new Map();
+};
+var generateEnumCached = (column, columnName, tableName) => {
+  const declared = declaredEnum(column);
+  const values = column.enumValues;
+  const name = enumNameMapper?.({
+    enumName: declared?.enumName,
+    schema: declared?.schema,
+    tableName,
+    columnName,
+    values
+  }) ?? (declared ? `${pascalize(declared.enumName)}Enum` : `${capitalize(tableName)}${capitalize(columnName)}Enum`);
+  const valuesKey = enumValuesKey(values);
+  const claimed = enumNamesInUse.get(name);
+  if (claimed) {
+    if (claimed.valuesKey !== valuesKey) {
+      throw new Error(
+        `Drizzle-GraphQL Error: Two different enums both map to the GraphQL type name '${name}' (most recently '${tableName}.${columnName}'). Give one of them a different name via config.enumNameMapper.`
+      );
+    }
+    return claimed.type;
+  }
+  const gqlEnum = new import_graphql2.GraphQLEnumType({
+    name,
+    values: Object.fromEntries(
+      values.map((e, index) => [
+        allowedNameChars.test(e) ? e : `Option${index}`,
+        {
+          value: e,
+          description: `Value: ${e}`
+        }
+      ])
+    )
+  });
+  enumNamesInUse.set(name, { type: gqlEnum, valuesKey });
+  return gqlEnum;
+};
+var geoXyType = new import_graphql2.GraphQLObjectType({
+  name: "PgGeometryObject",
+  fields: {
+    x: { type: import_graphql2.GraphQLFloat },
+    y: { type: import_graphql2.GraphQLFloat }
+  }
+});
+var geoXyInputType = new import_graphql2.GraphQLInputObjectType({
+  name: "PgGeometryObjectInput",
+  fields: {
+    x: { type: import_graphql2.GraphQLFloat },
+    y: { type: import_graphql2.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 innerLabel = inner.typeLabel ?? inner.type.name;
+    let type = inner.type;
+    let typeLabel = innerLabel;
+    for (let i = 0; i < dimensions; i++) {
+      type = new import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(type));
+      typeLabel = `Array<${typeLabel}>`;
+    }
+    return { type, typeLabel };
+  }
+  return columnBaseToGraphQLCore(column, columnName, tableName, isInput);
+};
+var columnBaseToGraphQLCore = (column, columnName, tableName, isInput) => {
+  const { type: baseType, constraint } = (0, import_drizzle_orm.extractExtendedColumnType)(column);
+  switch (baseType) {
+    case "boolean":
+      return { type: import_graphql2.GraphQLBoolean, typeLabel: "Boolean" };
+    case "object":
+      if (column instanceof import_pg_core.PgTimestamp || column instanceof import_pg_core.PgDate) {
+        return { type: import_graphql_scalars.GraphQLDateTime, typeLabel: "DateTime" };
+      }
+      return column.columnType === "PgGeometryObject" ? {
+        type: isInput ? geoXyInputType : geoXyType,
+        typeLabel: "Geometry points XY"
+      } : column.columnType === "PgBytea" ? {
+        type: new import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(import_graphql2.GraphQLInt)),
+        typeLabel: "Buffer"
+      } : { type: import_graphql_scalars.GraphQLJSON, typeLabel: "JSON" };
+    case "string":
+      if (column.enumValues?.length) {
+        return { type: generateEnumCached(column, columnName, tableName) };
+      }
+      if (constraint === "numeric" && !column.dimensions) {
+        return { type: GraphQLDecimalString, typeLabel: "Decimal" };
+      }
+      if (column instanceof import_pg_core.PgTimestamp || column instanceof import_pg_core.PgTimestampString) {
+        return { type: import_graphql_scalars.GraphQLDateTime, typeLabel: "DateTime" };
+      }
+      if (column instanceof import_pg_core.PgUUID) {
+        return { type: import_graphql_scalars.GraphQLUUID, typeLabel: "UUID" };
+      }
+      if (column instanceof import_pg_core.PgDateString) {
+        return isInput ? { type: import_graphql2.GraphQLString, typeLabel: "Date" } : { type: import_graphql_scalars.GraphQLDate, typeLabel: "Date" };
+      }
+      return { type: import_graphql2.GraphQLString, typeLabel: "String" };
+    case "bigint":
+      return { type: GraphQLBigIntString, typeLabel: "BigInt" };
+    case "number": {
+      return (0, import_drizzle_orm.is)(column, import_pg_core.PgInteger) || (0, import_drizzle_orm.is)(column, import_pg_core.PgSerial) || (0, import_drizzle_orm.is)(column, import_mysql_core.MySqlInt) || (0, import_drizzle_orm.is)(column, import_mysql_core.MySqlSerial) || (0, import_drizzle_orm.is)(column, import_sqlite_core.SQLiteInteger) ? { type: import_graphql2.GraphQLInt, typeLabel: "Integer" } : { type: import_graphql2.GraphQLFloat, typeLabel: "Float" };
+    }
+    case "array": {
+      if (column.columnType === "PgVector") {
+        return {
+          type: new import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(import_graphql2.GraphQLFloat)),
+          typeLabel: "Array<Float>"
+        };
+      }
+      if (column.columnType === "PgGeometry") {
+        return {
+          type: new import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(import_graphql2.GraphQLFloat)),
+          typeLabel: "Tuple<[Float, Float]>"
+        };
+      }
+      const innerType = columnToGraphQLCore(
+        column.baseColumn,
+        columnName,
+        tableName,
+        isInput
+      );
+      return {
+        type: new import_graphql2.GraphQLList(new import_graphql2.GraphQLNonNull(innerType.type)),
+        typeLabel: `Array<${innerType.typeLabel}>`
+      };
+    }
+    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 import_graphql2.GraphQLScalarType ? { output: override, input: override } : { output: override.output, input: override.input };
+  for (const scalar of [pair.output, pair.input]) {
+    if (scalar !== void 0 && !(scalar instanceof import_graphql2.GraphQLScalarType)) {
+      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((0, import_drizzle_orm.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);
+  const typeDesc = override ? { type: override, typeLabel: override.name } : columnToGraphQLCore(column, columnName, tableName, isInput);
+  if (forceNullable) {
+    return typeDesc;
+  }
+  if (column.notNull && !(defaultIsNullable && (column.hasDefault || column.defaultFn))) {
+    return {
+      type: new import_graphql2.GraphQLNonNull(typeDesc.type),
+      typeLabel: typeDesc.typeLabel
+    };
+  }
+  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)) {
@@ -139,6 +424,9 @@ var remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
   if (!column) {
     return value;
   }
+  if (getColumnScalarOverride(column, false)) {
+    return value;
+  }
   if (isJsonColumn(column)) {
     return value;
   }
@@ -169,7 +457,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 && (0, import_drizzle_orm.is)(relEntry.relation, import_drizzle_orm.One)) {
+      if (relEntry && (0, import_drizzle_orm2.is)(relEntry.relation, import_drizzle_orm2.One)) {
         queryOutput[key] = null;
         continue;
       }
@@ -192,13 +480,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 import_graphql.GraphQLError(`Field '${columnName}' is not a valid date!`);
+      throw new import_graphql3.GraphQLError(`Field '${columnName}' is not a valid date!`);
     }
     return formatted;
   }
@@ -207,7 +501,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 import_graphql.GraphQLError(`Field '${columnName}' is not a valid date!`);
+      throw new import_graphql3.GraphQLError(`Field '${columnName}' is not a valid date!`);
     }
     return dateOnly;
   }
@@ -215,7 +509,7 @@ var remapFromGraphQLCore = (value, column, columnName) => {
     try {
       return BigInt(value);
     } catch {
-      throw new import_graphql.GraphQLError(`Field '${columnName}' is not a BigInt!`);
+      throw new import_graphql3.GraphQLError(`Field '${columnName}' is not a BigInt!`);
     }
   }
   if (dataType.includes("json") && column.columnType !== "PgGeometryObject") {
@@ -225,13 +519,13 @@ var remapFromGraphQLCore = (value, column, columnName) => {
     case "date": {
       const formatted = new Date(value);
       if (Number.isNaN(formatted.getTime())) {
-        throw new import_graphql.GraphQLError(`Field '${columnName}' is not a valid date!`);
+        throw new import_graphql3.GraphQLError(`Field '${columnName}' is not a valid date!`);
       }
       return formatted;
     }
     case "buffer": {
       if (!Array.isArray(value)) {
-        throw new import_graphql.GraphQLError(`Field '${columnName}' is not an array!`);
+        throw new import_graphql3.GraphQLError(`Field '${columnName}' is not an array!`);
       }
       return Buffer.from(value);
     }
@@ -242,7 +536,7 @@ var remapFromGraphQLCore = (value, column, columnName) => {
       try {
         return JSON.parse(value);
       } catch (e) {
-        throw new import_graphql.GraphQLError(
+        throw new import_graphql3.GraphQLError(
           `Invalid JSON in field '${columnName}':
 ${e instanceof Error ? e.message : "Unknown error"}`
         );
@@ -250,10 +544,10 @@ ${e instanceof Error ? e.message : "Unknown error"}`
     }
     case "array": {
       if (!Array.isArray(value)) {
-        throw new import_graphql.GraphQLError(`Field '${columnName}' is not an array!`);
+        throw new import_graphql3.GraphQLError(`Field '${columnName}' is not an array!`);
       }
       if (column.columnType === "PgGeometry" && value.length !== 2) {
-        throw new import_graphql.GraphQLError(
+        throw new import_graphql3.GraphQLError(
           `Invalid float tuple in field '${columnName}': expected array with length of 2, received ${value.length}`
         );
       }
@@ -263,7 +557,7 @@ ${e instanceof Error ? e.message : "Unknown error"}`
       try {
         return BigInt(value);
       } catch (_error) {
-        throw new import_graphql.GraphQLError(`Field '${columnName}' is not a BigInt!`);
+        throw new import_graphql3.GraphQLError(`Field '${columnName}' is not a BigInt!`);
       }
     }
     default: {
@@ -279,9 +573,9 @@ var remapFromGraphQLSingleInput = (queryInput, table) => {
     if (value === void 0) {
       delete queryInput[key];
     } else {
-      const column = (0, import_drizzle_orm.getTableColumns)(table)[key];
+      const column = (0, import_drizzle_orm2.getTableColumns)(table)[key];
       if (!column) {
-        throw new import_graphql.GraphQLError(`Unknown column: ${key}`);
+        throw new import_graphql3.GraphQLError(`Unknown column: ${key}`);
       }
       if (value === null && column.notNull) {
         delete queryInput[key];
@@ -299,217 +593,6 @@ var remapFromGraphQLArrayInput = (queryInput, table) => {
   return queryInput;
 };
 
-// src/util/scalars/index.ts
-var import_graphql2 = require("graphql");
-var import_graphql_scalars = require("graphql-scalars");
-var asDecimalString = (value) => {
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  if (typeof value === "number") {
-    if (!Number.isInteger(value)) {
-      throw new import_graphql2.GraphQLError(`BigInt cannot represent non-integer value: ${value}`);
-    }
-    if (!Number.isSafeInteger(value)) {
-      throw new import_graphql2.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 import_graphql2.GraphQLError(`BigInt cannot represent non-integer value: "${value}"`);
-    }
-    return value;
-  }
-  throw new import_graphql2.GraphQLError(`BigInt cannot represent value: ${JSON.stringify(value)}`);
-};
-var GraphQLBigIntString = new import_graphql2.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 !== import_graphql2.Kind.STRING && ast.kind !== import_graphql2.Kind.INT) {
-      throw new import_graphql2.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 import_graphql2.GraphQLError(`Decimal cannot represent non-finite value: ${value}`);
-    }
-    return String(value);
-  }
-  if (typeof value === "string") {
-    if (!numericStringPattern.test(value)) {
-      throw new import_graphql2.GraphQLError(`Decimal cannot represent non-numeric value: "${value}"`);
-    }
-    return value;
-  }
-  throw new import_graphql2.GraphQLError(`Decimal cannot represent value: ${JSON.stringify(value)}`);
-};
-var GraphQLDecimalString = new import_graphql2.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 !== import_graphql2.Kind.STRING && ast.kind !== import_graphql2.Kind.INT && ast.kind !== import_graphql2.Kind.FLOAT) {
-      throw new import_graphql2.GraphQLError(`Decimal cannot represent a ${ast.kind}`, { nodes: ast });
-    }
-    return asNumericString(ast.value);
-  }
-});
-
-// src/util/type-converter/index.ts
-var import_drizzle_orm2 = require("drizzle-orm");
-var import_mysql_core = require("drizzle-orm/mysql-core");
-var import_pg_core = require("drizzle-orm/pg-core");
-var import_sqlite_core = require("drizzle-orm/sqlite-core");
-var import_graphql3 = require("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 import_graphql3.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 import_graphql3.GraphQLObjectType({
-  name: "PgGeometryObject",
-  fields: {
-    x: { type: import_graphql3.GraphQLFloat },
-    y: { type: import_graphql3.GraphQLFloat }
-  }
-});
-var geoXyInputType = new import_graphql3.GraphQLInputObjectType({
-  name: "PgGeometryObjectInput",
-  fields: {
-    x: { type: import_graphql3.GraphQLFloat },
-    y: { type: import_graphql3.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 import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(type));
-      description = `Array<${description}>`;
-    }
-    return { type, description };
-  }
-  return columnBaseToGraphQLCore(column, columnName, tableName, isInput);
-};
-var columnBaseToGraphQLCore = (column, columnName, tableName, isInput) => {
-  const { type: baseType, constraint } = (0, import_drizzle_orm2.extractExtendedColumnType)(column);
-  switch (baseType) {
-    case "boolean":
-      return { type: import_graphql3.GraphQLBoolean, description: "Boolean" };
-    case "object":
-      if (column instanceof import_pg_core.PgTimestamp || column instanceof import_pg_core.PgDate) {
-        return { type: import_graphql_scalars.GraphQLDateTime, description: "DateTime" };
-      }
-      return column.columnType === "PgGeometryObject" ? {
-        type: isInput ? geoXyInputType : geoXyType,
-        description: "Geometry points XY"
-      } : column.columnType === "PgBytea" ? {
-        type: new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(import_graphql3.GraphQLInt)),
-        description: "Buffer"
-      } : { type: import_graphql_scalars.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 import_pg_core.PgTimestamp || column instanceof import_pg_core.PgTimestampString) {
-        return { type: import_graphql_scalars.GraphQLDateTime, description: "DateTime" };
-      }
-      if (column instanceof import_pg_core.PgUUID) {
-        return { type: import_graphql_scalars.GraphQLUUID, description: "UUID" };
-      }
-      if (column instanceof import_pg_core.PgDateString) {
-        return isInput ? { type: import_graphql3.GraphQLString, description: "Date" } : { type: import_graphql_scalars.GraphQLDate, description: "Date" };
-      }
-      return { type: import_graphql3.GraphQLString, description: "String" };
-    case "bigint":
-      return { type: GraphQLBigIntString, description: "BigInt" };
-    case "number": {
-      return (0, import_drizzle_orm2.is)(column, import_pg_core.PgInteger) || (0, import_drizzle_orm2.is)(column, import_pg_core.PgSerial) || (0, import_drizzle_orm2.is)(column, import_mysql_core.MySqlInt) || (0, import_drizzle_orm2.is)(column, import_mysql_core.MySqlSerial) || (0, import_drizzle_orm2.is)(column, import_sqlite_core.SQLiteInteger) ? { type: import_graphql3.GraphQLInt, description: "Integer" } : { type: import_graphql3.GraphQLFloat, description: "Float" };
-    }
-    case "array": {
-      if (column.columnType === "PgVector") {
-        return {
-          type: new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(import_graphql3.GraphQLFloat)),
-          description: "Array<Float>"
-        };
-      }
-      if (column.columnType === "PgGeometry") {
-        return {
-          type: new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(import_graphql3.GraphQLFloat)),
-          description: "Tuple<[Float, Float]>"
-        };
-      }
-      const innerType = columnToGraphQLCore(
-        column.baseColumn,
-        columnName,
-        tableName,
-        isInput
-      );
-      return {
-        type: new import_graphql3.GraphQLList(new import_graphql3.GraphQLNonNull(innerType.type)),
-        description: `Array<${innerType.description}>`
-      };
-    }
-    default:
-      throw new Error(`Drizzle-GraphQL Error: Type ${column.dataType} is not implemented!`);
-  }
-};
-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 } = (0, import_drizzle_orm2.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 import_graphql3.GraphQLNonNull(typeDesc.type),
-      description: typeDesc.description
-    };
-  }
-  return typeDesc;
-};
-
 // src/util/builders/common.ts
 var rqbCrashTypes = ["SQLiteBigInt", "SQLiteBlobJson", "SQLiteBlobBuffer"];
 var resolveTypeName = (name, typeNameMapper) => {
@@ -887,6 +970,22 @@ var createRelationResolverFactory = (db, tables, filterCtx) => ({ tableName, rel
     return loader.load(localValue);
   };
 };
+var columnDocs = (docs, column, tableName, columnName) => {
+  const description = docs.describeColumn?.(column, { tableName, columnName });
+  const deprecationReason = docs.deprecateColumn?.(column, { tableName, columnName });
+  return {
+    ...description !== void 0 ? { description } : {},
+    ...deprecationReason !== void 0 ? { deprecationReason } : {}
+  };
+};
+var inputFieldDocs = (docs, column, tableName, columnName, fieldType) => {
+  const resolved = columnDocs(docs, column, tableName, columnName);
+  if (resolved.deprecationReason !== void 0 && fieldType instanceof import_graphql4.GraphQLNonNull) {
+    const { deprecationReason: _dropped, ...rest } = resolved;
+    return rest;
+  }
+  return resolved;
+};
 var listFieldComplexity = (options) => ({ args, childComplexity }) => {
   const limit = args["limit"];
   const rows = typeof limit === "number" && limit > 0 ? limit : options.defaultListSize;
@@ -894,18 +993,21 @@ var listFieldComplexity = (options) => ({ args, childComplexity }) => {
 };
 var aggregateFieldComplexity = (options) => ({ childComplexity }) => options.aggregateCost + childComplexity;
 var AGGREGATE_FIELD_SUFFIX = "Aggregate";
-var relationAggregateJoinColumns = (tree, table, selectionCtx) => {
-  const relations = selectionCtx?.relationMap[selectionCtx.tableName];
-  if (!relations || !selectionCtx) {
+var relationJoinColumns = (tree, table, selectionCtx) => {
+  if (!selectionCtx) {
+    return [];
+  }
+  const relations = (selectionCtx.allRelations ?? selectionCtx.relationMap)[selectionCtx.tableName] ?? selectionCtx.relationMap[selectionCtx.tableName];
+  if (!relations) {
     return [];
   }
   const tableColumns = (0, import_drizzle_orm3.getColumns)(table);
   const needed = [];
   for (const fieldData of Object.values(tree)) {
-    if (tableColumns[fieldData.name] || !fieldData.name.endsWith(AGGREGATE_FIELD_SUFFIX)) {
+    if (tableColumns[fieldData.name]) {
       continue;
     }
-    const relEntry = relations[fieldData.name.slice(0, -AGGREGATE_FIELD_SUFFIX.length)];
+    const relEntry = fieldData.name.endsWith(AGGREGATE_FIELD_SUFFIX) ? relations[fieldData.name.slice(0, -AGGREGATE_FIELD_SUFFIX.length)] : relations[fieldData.name];
     const targetTable = relEntry ? selectionCtx.tables[relEntry.targetTableName] : void 0;
     if (!relEntry || !targetTable) {
       continue;
@@ -927,7 +1029,7 @@ var extractSelectedColumnsFromTree = (tree, table, selectionCtx) => {
     }
     selectedColumns.push([fieldData.name, true]);
   }
-  for (const columnName of relationAggregateJoinColumns(tree, table, selectionCtx)) {
+  for (const columnName of relationJoinColumns(tree, table, selectionCtx)) {
     selectedColumns.push([columnName, true]);
   }
   if (!selectedColumns.length) {
@@ -947,7 +1049,7 @@ var extractSelectedColumnsFromTreeSQLFormat = (tree, table, selectionCtx) => {
     }
     selectedColumns.push([fieldData.name, tableColumns[fieldData.name]]);
   }
-  for (const columnName of relationAggregateJoinColumns(tree, table, selectionCtx)) {
+  for (const columnName of relationJoinColumns(tree, table, selectionCtx)) {
     selectedColumns.push([columnName, tableColumns[columnName]]);
   }
   if (!selectedColumns.length) {
@@ -1068,44 +1170,69 @@ var jsonFilterFields = (column, colType) => {
     isNotNull: { type: import_graphql4.GraphQLBoolean }
   };
 };
-var arrayFilterFields = (colType, colArr, colDesc) => {
+var IN_ARRAY_DESCRIPTION = "Matches any one of these values (SQL `IN`)";
+var NOT_IN_ARRAY_DESCRIPTION = "Matches none of these values (SQL `NOT IN`)";
+var arrayFilterFields = (colType, colArr) => {
   let element = colType.ofType;
   if (element instanceof import_graphql4.GraphQLNonNull) {
     element = element.ofType;
   }
   const elementList = new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(element));
   return {
-    eq: { type: colType, description: colDesc },
-    ne: { type: colType, description: colDesc },
+    eq: { type: colType, description: "The whole array equals this array" },
+    ne: { type: colType, description: "The whole array differs from this array" },
     has: { type: element, description: "Array contains this element" },
     hasSome: { type: elementList, description: "Array contains at least one of these elements (overlap, `&&`)" },
     hasEvery: { type: elementList, description: "Array contains every one of these elements (containment, `@>`)" },
     isEmpty: { type: import_graphql4.GraphQLBoolean, description: "When true, matches arrays with no elements" },
-    inArray: { type: colArr, description: `Array<${colDesc}>` },
-    notInArray: { type: colArr, description: `Array<${colDesc}>` },
+    inArray: { type: colArr, description: IN_ARRAY_DESCRIPTION },
+    notInArray: { type: colArr, description: NOT_IN_ARRAY_DESCRIPTION },
     isNull: { type: import_graphql4.GraphQLBoolean },
     isNotNull: { type: import_graphql4.GraphQLBoolean }
   };
 };
 var FILTERS_WITHOUT_STRING_OPS = /* @__PURE__ */ new Set(["Id", "Int", "Float", "BigInt", "Decimal"]);
+var BUILTIN_FILTER_SCALARS = /* @__PURE__ */ new Set([
+  import_graphql4.GraphQLString,
+  import_graphql4.GraphQLInt,
+  import_graphql4.GraphQLFloat,
+  import_graphql4.GraphQLBoolean,
+  GraphQLBigIntString,
+  GraphQLDecimalString,
+  import_graphql_scalars.GraphQLUUID,
+  import_graphql_scalars.GraphQLJSON,
+  import_graphql_scalars.GraphQLDate,
+  import_graphql_scalars.GraphQLDateTime
+]);
+var resolveOverrideFilterDescriptor = (scalar) => {
+  if (scalar === import_graphql_scalars.GraphQLJSON) {
+    return { name: "JSON", kind: "json" };
+  }
+  if (scalar === import_graphql_scalars.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;
   }
   const colType = columnGraphQLType.type;
-  const colDesc = columnGraphQLType.description;
   const colArr = new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(colType));
-  const omitStringOps = 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 },
-    lt: { type: colType, description: colDesc },
-    lte: { type: colType, description: colDesc },
-    gt: { type: colType, description: colDesc },
-    gte: { type: colType, description: colDesc },
+  const customOverrideFilter = inputOverride !== void 0 && !BUILTIN_FILTER_SCALARS.has(inputOverride);
+  const underlying = (0, import_drizzle_orm3.extractExtendedColumnType)(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) : {
+    eq: { type: colType, description: "Equal to" },
+    ne: { type: colType, description: "Not equal to" },
+    lt: { type: colType, description: "Less than" },
+    lte: { type: colType, description: "Less than or equal to" },
+    gt: { type: colType, description: "Greater than" },
+    gte: { type: colType, description: "Greater than or equal to" },
     ...omitStringOps ? {} : {
       like: { type: import_graphql4.GraphQLString },
       notLike: { type: import_graphql4.GraphQLString },
@@ -1136,10 +1263,10 @@ var generateColumnFilterValues = (column, tableName, columnName, cacheCtx) => {
         description: "Case-insensitive `contains`."
       }
     },
-    inArray: { type: colArr, description: `Array<${colDesc}>` },
-    notInArray: { type: colArr, description: `Array<${colDesc}>` },
-    isNull: { type: import_graphql4.GraphQLBoolean },
-    isNotNull: { type: import_graphql4.GraphQLBoolean }
+    inArray: { type: colArr, description: IN_ARRAY_DESCRIPTION },
+    notInArray: { type: colArr, description: NOT_IN_ARRAY_DESCRIPTION },
+    isNull: { type: import_graphql4.GraphQLBoolean, description: "When true, matches rows where the column is NULL" },
+    isNotNull: { type: import_graphql4.GraphQLBoolean, description: "When true, matches rows where the column is not NULL" }
   };
   const mainType = new import_graphql4.GraphQLInputObjectType({
     name: `${genericName}Filter`,
@@ -1179,35 +1306,40 @@ 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 = (0, import_drizzle_orm3.getColumns)(table);
   const columnEntries = Object.entries(columns);
   const remapped = Object.fromEntries(
-    columnEntries.map(([columnName, columnDescription]) => [
+    columnEntries.map(([columnName, column]) => [
       columnName,
       {
-        type: generateColumnFilterValues(columnDescription, tableName, columnName, cacheCtx)
+        type: generateColumnFilterValues(column, tableName, columnName, cacheCtx),
+        // A filter field is the same column, so it carries the same documentation. Deprecation
+        // is not propagated: filtering on a deprecated column is how a caller finds the rows
+        // that still use it.
+        ...cacheCtx.docs.describeColumn ? { description: cacheCtx.docs.describeColumn(column, { tableName, columnName }) } : {}
       }
     ])
   );
-  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 = (0, import_drizzle_orm3.getColumns)(table);
   const columnEntries = Object.entries(columns);
   const remapped = Object.fromEntries(
-    columnEntries.map(([columnName, columnDescription]) => [
+    columnEntries.map(([columnName, column]) => [
       columnName,
-      drizzleColumnToGraphQLType(columnDescription, columnName, tableName)
+      {
+        ...drizzleColumnToGraphQLType(column, columnName, tableName),
+        ...columnDocs(cacheCtx.docs, column, tableName, columnName)
+      }
     ])
   );
   if (!remapped[CURSOR_FIELD_NAME]) {
@@ -1217,7 +1349,7 @@ var generateTableSelectTypeFieldsCached = (table, tableName) => {
       resolve: rowCursorResolver
     };
   }
-  fieldMap.set(table, remapped);
+  cacheCtx.selectFieldCache.set(table, remapped);
   return remapped;
 };
 var isFilterableRelation = (relation) => !relation.through;
@@ -1367,7 +1499,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) {
@@ -1404,6 +1536,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
     const typeName = resolveTypeName(tableName, typeNameMapper);
     const shell = new import_graphql4.GraphQLObjectType({
       name: typeName,
+      description: cacheCtx.docs.describeTable?.(tableName),
       fields: () => ({ ...tableFields, ...container.fields })
     });
     cacheCtx.objectTypeCache.set(tableName, shell);
@@ -1436,7 +1569,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: {} };
@@ -1445,11 +1578,14 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
         const capturedTargetContainer = targetContainer;
         relType = new import_graphql4.GraphQLObjectType({
           name: resolveTypeName(targetTableName, typeNameMapper),
+          description: cacheCtx.docs.describeTable?.(targetTableName),
           fields: () => ({ ...targetTableFields, ...capturedTargetContainer.fields })
         });
         cacheCtx.objectTypeCache.set(targetTableName, relType);
       }
       const resolve = resolverFactory?.({ tableName, relationName, relEntry, isOne });
+      const relationDescription = cacheCtx.docs.describeRelation?.(tableName, relationName);
+      const relationDocs = relationDescription !== void 0 ? { description: relationDescription } : {};
       if (isOne) {
         const isRequired = relation.optional === false;
         rawRelationFields.push([
@@ -1459,7 +1595,8 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
             args: {
               where: { type: relSelectData.filters }
             },
-            resolve
+            resolve,
+            ...relationDocs
           }
         ]);
         continue;
@@ -1475,6 +1612,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
             limit: { type: import_graphql4.GraphQLInt }
           },
           resolve,
+          ...relationDocs,
           ...cacheCtx.complexity ? { extensions: { complexity: listFieldComplexity(cacheCtx.complexity) } } : {}
         }
       ]);
@@ -1522,7 +1660,7 @@ var generateSelectFields = (tables, tableName, relationMap, fromTableName, fromR
     relationFields: {}
   };
 };
-var generateTableTypes = (tableName, tables, relationMap, withReturning, relationsDepthLimit, cacheCtx, typeNameMapper = void 0, insertPrefix = "create", updatePrefix = "update", resolverFactory, relationAggregateFactory) => {
+var generateTableTypes = (tableName, tables, relationMap, withReturning, relationsDepthLimit, cacheCtx, typeNameMapper = void 0, insertPrefix = "create", updatePrefix = "update", resolverFactory, relationAggregateFactory, nestedWrites) => {
   const { tableFields, relationFields, filters, order } = generateSelectFields(
     tables,
     tableName,
@@ -1543,28 +1681,44 @@ var generateTableTypes = (tableName, tables, relationMap, withReturning, relatio
   const table = tables[tableName];
   const columns = (0, import_drizzle_orm3.getColumns)(table);
   const columnEntries = Object.entries(columns);
+  const relaxedColumns = nestedWrites?.relaxedColumns(tableName);
   const insertFields = Object.fromEntries(
-    columnEntries.map(([columnName, columnDescription]) => [
-      columnName,
-      drizzleColumnToGraphQLType(columnDescription, columnName, tableName, false, true, true)
-    ])
+    columnEntries.map(([columnName, column]) => {
+      const converted = drizzleColumnToGraphQLType(
+        column,
+        columnName,
+        tableName,
+        !!relaxedColumns?.has(columnName),
+        true,
+        true
+      );
+      return [
+        columnName,
+        { ...converted, ...inputFieldDocs(cacheCtx.docs, column, tableName, columnName, converted.type) }
+      ];
+    })
   );
   const updateFields = Object.fromEntries(
-    columnEntries.map(([columnName, columnDescription]) => [
-      columnName,
-      drizzleColumnToGraphQLType(columnDescription, columnName, tableName, true, false, true)
-    ])
+    columnEntries.map(([columnName, column]) => {
+      const converted = drizzleColumnToGraphQLType(column, columnName, tableName, true, false, true);
+      return [
+        columnName,
+        { ...converted, ...inputFieldDocs(cacheCtx.docs, column, tableName, columnName, converted.type) }
+      ];
+    })
   );
+  const typeName = resolveTypeName(tableName, typeNameMapper);
   const insertInput = new import_graphql4.GraphQLInputObjectType({
-    name: `${capitalize(insertPrefix)}${resolveTypeName(tableName, typeNameMapper)}Input`,
-    fields: insertFields
+    name: `${capitalize(insertPrefix)}${typeName}Input`,
+    fields: nestedWrites ? () => ({ ...insertFields, ...nestedWrites.createFields(tableName, typeName) }) : insertFields
   });
   const updateInput = new import_graphql4.GraphQLInputObjectType({
-    name: `${capitalize(updatePrefix)}${resolveTypeName(tableName, typeNameMapper)}Input`,
-    fields: updateFields
+    name: `${capitalize(updatePrefix)}${typeName}Input`,
+    fields: nestedWrites ? () => ({ ...updateFields, ...nestedWrites.updateFields(tableName, typeName) }) : updateFields
   });
   const selectSingleOutput = cacheCtx.objectTypeCache.get(tableName) ?? new import_graphql4.GraphQLObjectType({
     name: resolveTypeName(tableName, typeNameMapper),
+    description: cacheCtx.docs.describeTable?.(tableName),
     fields: { ...tableFields, ...relationFields }
   });
   const selectArrOutput = new import_graphql4.GraphQLNonNull(new import_graphql4.GraphQLList(new import_graphql4.GraphQLNonNull(selectSingleOutput)));
@@ -1956,6 +2110,13 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
     if (!field) {
       continue;
     }
+    const selectionCount = Object.values(baseField).reduce(
+      (n, f) => n + (f.name === relName ? 1 : 0),
+      0
+    );
+    if (selectionCount > 1) {
+      continue;
+    }
     const relField = field?.fieldsByTypeName;
     const relFieldSelection = relField?.[relTypeName];
     if (!relFieldSelection) {
@@ -1964,7 +2125,8 @@ var extractRelationsParamsInner = (relationMap, tables, tableName, typeName, ori
     const columns = extractSelectedColumnsFromTree(relFieldSelection, tables[targetTableName], {
       tableName: targetTableName,
       relationMap,
-      tables
+      tables,
+      allRelations: filterCtx?.relationMap
     });
     const thisRecord = {};
     thisRecord.columns = columns;
@@ -2570,7 +2732,8 @@ var runRelationalSelect = async (opts) => {
     columns: extractSelectedColumnsFromTree(parsedInfo.fieldsByTypeName[typeName], table, {
       tableName,
       relationMap,
-      tables
+      tables,
+      allRelations: filterCtx?.relationMap
     }),
     offset: distinctKeys ? void 0 : offset,
     // drizzle-orm v1 RQB calls orderBy/where with the aliased table proxy — use it
@@ -2751,9 +2914,9 @@ var generateAggregateTypes = (table, tableName, typeName, cacheCtx) => {
         type: new import_graphql5.GraphQLObjectType({
           name: `${typeName}${capitalize(op)}Aggregate`,
           fields: Object.fromEntries(
-            Object.entries(orderable).map(([columnName, { converted }]) => [
+            Object.entries(orderable).map(([columnName, { column, converted }]) => [
               columnName,
-              { type: converted.type, description: converted.description }
+              { type: converted.type, ...columnDocs(cacheCtx?.docs ?? {}, column, tableName, columnName) }
             ])
           )
         })
@@ -2800,7 +2963,7 @@ var aggregateTarget = (table, tableName, typeName) => {
     typeName,
     columns: (0, import_drizzle_orm4.getColumns)(table),
     dateTimeColumns: new Set(
-      Object.entries(orderable).filter(([, { converted }]) => converted.description === "DateTime").map(([columnName]) => columnName)
+      Object.entries(orderable).filter(([, { converted }]) => converted.typeLabel === "DateTime").map(([columnName]) => columnName)
     )
   };
 };
@@ -3018,9 +3181,9 @@ var generateGroupByType = (table, tableName, typeName, cacheCtx) => {
     name: `${typeName}GroupKeys`,
     description: `The grouped column values of one ${typeName} group. A column the query did not group by is null.`,
     fields: Object.fromEntries(
-      Object.entries(groupable).map(([columnName, { converted }]) => [
+      Object.entries(groupable).map(([columnName, { column, converted }]) => [
         columnName,
-        { type: converted.type, description: converted.description }
+        { type: converted.type, ...columnDocs(cacheCtx?.docs ?? {}, column, tableName, columnName) }
       ])
     )
   });
@@ -3420,6 +3583,13 @@ 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?"
     );
   }
+  if (features.nestedWrites) {
+    throw new Error(
+      "Drizzle-GraphQL Error: features.nestedWrites is not supported on MySQL \u2014 a nested write needs the parent row it just inserted returned to it, and MySQL has no RETURNING clause."
+    );
+  }
+  registerScalarOverrides(tables, options);
+  registerEnumConfig(options);
   const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
   attachTargetPrimaryKeys(namedRelations, tables, mysqlPrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
@@ -3431,11 +3601,14 @@ 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(),
     aggregateTypeCache: /* @__PURE__ */ new Map(),
-    complexity
+    complexity,
+    docs: options.docs ?? {}
   };
   const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
@@ -3683,54 +3856,433 @@ var generateSchemaData = (db, schema, relations, options) => {
         };
       }
     }
-    const activeInputs = [
-      // The insert input types the upsert mutations too, so either feature keeps it.
-      ...features.insert || onConflictInput ? [insertInput] : [],
-      ...onConflictInput ? [onConflictInput] : [],
-      ...features.update ? [updateInput] : [],
-      ...updateManyInput ? [updateManyInput] : [],
-      tableFilters,
-      tableOrder
-    ];
-    activeInputs.forEach((e) => {
-      inputs[e.name] = e;
+    const activeInputs = [
+      // The insert input types the upsert mutations too, so either feature keeps it.
+      ...features.insert || onConflictInput ? [insertInput] : [],
+      ...onConflictInput ? [onConflictInput] : [],
+      ...features.update ? [updateInput] : [],
+      ...updateManyInput ? [updateManyInput] : [],
+      tableFilters,
+      tableOrder
+    ];
+    activeInputs.forEach((e) => {
+      inputs[e.name] = e;
+    });
+    outputs[selectSingleOutput.name] = selectSingleOutput;
+    if (aggregateType) {
+      outputs[aggregateType.name] = aggregateType;
+    }
+    if (groupByType && havingInput) {
+      outputs[groupByType.name] = groupByType;
+      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 = {};
+    for (const [relName, relEntry] of Object.entries(tableRelations)) {
+      const isOne = (0, import_drizzle_orm5.is)(relEntry.relation ?? relEntry, import_drizzle_orm5.One);
+      const resolver = resolverFactory({ tableName, relationName: relName, relEntry, isOne });
+      if (resolver) {
+        relResolvers[relName] = resolver;
+      }
+    }
+    if (Object.keys(relResolvers).length > 0) {
+      fieldResolvers[tableName] = relResolvers;
+    }
+  }
+  return { queries, mutations, inputs, types: outputs, fieldResolvers };
+};
+
+// src/util/builders/pg.ts
+var import_drizzle_orm7 = require("drizzle-orm");
+var import_pg_core2 = require("drizzle-orm/pg-core");
+var import_graphql8 = require("graphql");
+var import_graphql_parse_resolve_info3 = require("graphql-parse-resolve-info");
+
+// src/util/builders/nested-writes.ts
+var import_drizzle_orm6 = require("drizzle-orm");
+var import_graphql7 = require("graphql");
+var isOptionalOnInsert = (column) => !column.notNull || !!column.hasDefault || !!column.defaultFn;
+var buildNestedWritePlans = (tables, relationMap, resolveUniqueSets, resolvePrimaryKeys, extractJoinColumns) => {
+  const uniqueCache = /* @__PURE__ */ new Map();
+  const singleColumnUniques = (tableName, table) => {
+    let cached = uniqueCache.get(tableName);
+    if (!cached) {
+      cached = new Set(
+        resolveUniqueSets(table).filter((set) => set.length === 1).map((set) => set[0])
+      );
+      uniqueCache.set(tableName, cached);
+    }
+    return cached;
+  };
+  const pkCache = /* @__PURE__ */ new Map();
+  const singleColumnPk = (tableName, table) => {
+    if (!pkCache.has(tableName)) {
+      const pk = resolvePrimaryKeys(table);
+      pkCache.set(tableName, pk.length === 1 ? pk[0] : void 0);
+    }
+    return pkCache.get(tableName);
+  };
+  const plans = {};
+  for (const [tableName, relations] of Object.entries(relationMap)) {
+    const table = tables[tableName];
+    if (!table) {
+      continue;
+    }
+    const tablePlans = {};
+    for (const [relationName, relEntry] of Object.entries(relations)) {
+      const relation = relEntry.relation;
+      if (relation.through) {
+        continue;
+      }
+      const targetTableName = relEntry.targetTableName;
+      const targetTable = tables[targetTableName];
+      if (!targetTable) {
+        continue;
+      }
+      const joinColumns = extractJoinColumns(relEntry, table, targetTable);
+      if (!joinColumns) {
+        continue;
+      }
+      const { localColPropName, foreignCol, foreignColPropName } = joinColumns;
+      const localCol = (0, import_drizzle_orm6.getColumns)(table)[localColPropName];
+      if (!localCol) {
+        continue;
+      }
+      const isOne = (0, import_drizzle_orm6.is)(relation, import_drizzle_orm6.One);
+      const localIsPk = singleColumnPk(tableName, table) === localColPropName;
+      const foreignIsPk = singleColumnPk(targetTableName, targetTable) === foreignColPropName;
+      const localIsUnique = singleColumnUniques(tableName, table).has(localColPropName);
+      const foreignIsUnique = singleColumnUniques(targetTableName, targetTable).has(foreignColPropName);
+      let fkSide;
+      if (!isOne) {
+        fkSide = "child";
+      } else if (foreignIsPk && !localIsPk) {
+        fkSide = "parent";
+      } else if (localIsPk) {
+        fkSide = "child";
+      } else if (foreignIsUnique) {
+        fkSide = "parent";
+      } else if (localIsUnique) {
+        fkSide = "child";
+      } else {
+        continue;
+      }
+      const fkColumn = fkSide === "child" ? foreignCol : localCol;
+      tablePlans[relationName] = {
+        relationName,
+        targetTableName,
+        targetTable,
+        localColPropName,
+        foreignColPropName,
+        foreignCol,
+        localCol,
+        isOne,
+        fkSide,
+        canDetach: !fkColumn.notNull
+      };
+    }
+    if (Object.keys(tablePlans).length) {
+      plans[tableName] = tablePlans;
+    }
+  }
+  return plans;
+};
+var NO_COLUMNS = /* @__PURE__ */ new Set();
+var createNestedWriteTypes = (params) => {
+  const { plans, cacheCtx, typeNameMapper, insertPrefix } = params;
+  const wrapperCache = /* @__PURE__ */ new Map();
+  const payloadCache = /* @__PURE__ */ new Map();
+  const payloadType = (tableName, typeName, plan) => {
+    const key = `${tableName}.${plan.relationName}`;
+    const cached = payloadCache.get(key);
+    if (cached) {
+      return cached;
+    }
+    const omitted = plan.fkSide === "child" ? plan.foreignColPropName : void 0;
+    const fields = Object.fromEntries(
+      Object.entries((0, import_drizzle_orm6.getColumns)(plan.targetTable)).filter(([columnName]) => columnName !== omitted).map(([columnName, column]) => [
+        columnName,
+        drizzleColumnToGraphQLType(column, columnName, plan.targetTableName, false, true, true)
+      ])
+    );
+    const type = new import_graphql7.GraphQLInputObjectType({
+      name: `${capitalize(insertPrefix)}${typeName}${capitalize(plan.relationName)}Input`,
+      description: omitted === void 0 ? `A new ${resolveTypeName(plan.targetTableName, typeNameMapper)} row for ${typeName}.${plan.relationName}` : `A new ${resolveTypeName(plan.targetTableName, typeNameMapper)} row for ${typeName}.${plan.relationName}. \`${omitted}\` is set from the ${typeName} row this is written with.`,
+      fields
+    });
+    payloadCache.set(key, type);
+    return type;
+  };
+  const targetFilters = (plan) => cacheCtx.filterTypeCache.get(plan.targetTable);
+  const listOf = (type) => new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(type));
+  const wrapperType = (tableName, typeName, plan, forUpdate) => {
+    const key = `${tableName}.${plan.relationName}.${forUpdate ? "update" : "create"}`;
+    const cached = wrapperCache.get(key);
+    if (cached) {
+      return cached;
+    }
+    const filters = targetFilters(plan);
+    const payload = payloadType(tableName, typeName, plan);
+    const targetTypeName = resolveTypeName(plan.targetTableName, typeNameMapper);
+    const fields = {};
+    if (plan.isOne) {
+      fields["create"] = { type: payload, description: `Insert a ${targetTypeName} row and attach it` };
+      if (filters) {
+        fields["connect"] = {
+          type: filters,
+          description: `Attach the existing ${targetTypeName} row this matches. Must match exactly one row.`
+        };
+      }
+      if (forUpdate && plan.canDetach) {
+        fields["disconnect"] = {
+          type: import_graphql7.GraphQLBoolean,
+          description: `Detach the currently attached ${targetTypeName} row, leaving it in place`
+        };
+      }
+    } else {
+      fields["create"] = { type: listOf(payload), description: `Insert these ${targetTypeName} rows and attach them` };
+      if (filters) {
+        fields["connect"] = {
+          type: listOf(filters),
+          description: `Attach every existing ${targetTypeName} row these match`
+        };
+        if (forUpdate && plan.canDetach) {
+          fields["disconnect"] = {
+            type: listOf(filters),
+            description: `Detach every attached ${targetTypeName} row these match, leaving the rows in place`
+          };
+          fields["set"] = {
+            type: listOf(filters),
+            description: `Replace the whole set: detach everything attached, then attach every ${targetTypeName} row these match. Applied before \`disconnect\`, \`connect\` and \`create\`.`
+          };
+        }
+      }
+    }
+    const type = new import_graphql7.GraphQLInputObjectType({
+      name: `${typeName}${capitalize(plan.relationName)}Nested${forUpdate ? "Update" : "Create"}Input`,
+      description: `Writes through ${typeName}.${plan.relationName}`,
+      fields
     });
-    outputs[selectSingleOutput.name] = selectSingleOutput;
-    if (aggregateType) {
-      outputs[aggregateType.name] = aggregateType;
+    wrapperCache.set(key, type);
+    return type;
+  };
+  const relationFields = (tableName, typeName, forUpdate) => {
+    const tablePlans = plans[tableName];
+    if (!tablePlans) {
+      return {};
+    }
+    return Object.fromEntries(
+      Object.values(tablePlans).flatMap((plan) => {
+        const wrapper = wrapperType(tableName, typeName, plan, forUpdate);
+        return wrapper ? [[plan.relationName, { type: wrapper, description: `Writes through ${typeName}.${plan.relationName}` }]] : [];
+      })
+    );
+  };
+  return {
+    createFields: (tableName, typeName) => relationFields(tableName, typeName, false),
+    updateFields: (tableName, typeName) => relationFields(tableName, typeName, true),
+    relaxedColumns: (tableName) => {
+      const tablePlans = plans[tableName];
+      if (!tablePlans) {
+        return NO_COLUMNS;
+      }
+      const relaxed = /* @__PURE__ */ new Set();
+      for (const plan of Object.values(tablePlans)) {
+        if (plan.fkSide === "parent" && !isOptionalOnInsert(plan.localCol)) {
+          relaxed.add(plan.localColPropName);
+        }
+      }
+      return relaxed.size ? relaxed : NO_COLUMNS;
     }
-    if (groupByType && havingInput) {
-      outputs[groupByType.name] = groupByType;
-      inputs[havingInput.name] = havingInput;
+  };
+};
+var mergedOps = (entries) => Object.assign({}, ...entries.map((entry) => entry.ops));
+var asArray = (value) => Array.isArray(value) ? value : value === void 0 ? [] : [value];
+var createNestedWriteRuntime = (params) => {
+  const { plans, filterCtx } = params;
+  const conditionOf = (plan, filter, operation) => {
+    const condition = extractFilters(
+      plan.targetTable,
+      plan.targetTableName,
+      filter,
+      relationFilterCtx(filterCtx, plan.targetTableName)
+    );
+    if (!condition) {
+      throw new import_graphql7.GraphQLError(
+        `Drizzle-GraphQL Error: '${operation}' on '${plan.relationName}' needs a filter that selects rows \u2014 it was given one that matches everything.`
+      );
     }
-  }
-  if (mutationTxCtx) {
-    for (const name of Object.keys(mutations)) {
-      mutationTxCtx.fieldNames.add(name);
+    return condition;
+  };
+  const assertSingleOperation = (plan, op) => {
+    const supplied = ["create", "connect", "disconnect"].filter((key) => op[key] !== void 0 && op[key] !== null);
+    if (supplied.length > 1) {
+      throw new import_graphql7.GraphQLError(
+        `Drizzle-GraphQL Error: '${plan.relationName}' takes one of ${supplied.join(", ")} at a time \u2014 it holds a single row.`
+      );
     }
-  }
-  const fieldResolvers = {};
-  for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
-    const relResolvers = {};
-    for (const [relName, relEntry] of Object.entries(tableRelations)) {
-      const isOne = (0, import_drizzle_orm5.is)(relEntry.relation ?? relEntry, import_drizzle_orm5.One);
-      const resolver = resolverFactory({ tableName, relationName: relName, relEntry, isOne });
-      if (resolver) {
-        relResolvers[relName] = resolver;
+  };
+  const detachAll = async (executor, plan, key) => executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where((0, import_drizzle_orm6.eq)(plan.foreignCol, key));
+  return {
+    enabled: (tableName) => !!plans[tableName],
+    split: (tableName, values) => {
+      const tablePlans = plans[tableName];
+      if (!tablePlans) {
+        return { columns: values, ops: {} };
+      }
+      const columns = {};
+      const ops = {};
+      for (const [key, value] of Object.entries(values)) {
+        if (tablePlans[key] && value !== void 0 && value !== null) {
+          ops[key] = value;
+        } else if (!tablePlans[key]) {
+          columns[key] = value;
+        }
+      }
+      return { columns, ops };
+    },
+    hasOps: (ops) => Object.keys(ops).length > 0,
+    withJoinColumns: (tableName, ops, columns, table) => {
+      const tablePlans = plans[tableName];
+      if (!tablePlans) {
+        return columns;
+      }
+      const allColumns = (0, import_drizzle_orm6.getColumns)(table);
+      for (const relationName of Object.keys(ops)) {
+        const plan = tablePlans[relationName];
+        if (plan?.fkSide === "child" && !(plan.localColPropName in columns) && allColumns[plan.localColPropName]) {
+          columns[plan.localColPropName] = allColumns[plan.localColPropName];
+        }
+      }
+      return columns;
+    },
+    applyParentSide: async (executor, tableName, ops) => {
+      const tablePlans = plans[tableName];
+      const patch = {};
+      if (!tablePlans) {
+        return patch;
+      }
+      for (const [relationName, op] of Object.entries(ops)) {
+        const plan = tablePlans[relationName];
+        if (!plan || plan.fkSide !== "parent") {
+          continue;
+        }
+        assertSingleOperation(plan, op);
+        if (op["create"] !== void 0) {
+          const values = remapFromGraphQLSingleInput({ ...op["create"] }, plan.targetTable);
+          const inserted = await executor.insert(plan.targetTable).values(values).returning();
+          const created = inserted[0];
+          if (!created) {
+            throw new import_graphql7.GraphQLError(
+              `Drizzle-GraphQL Error: 'create' on '${relationName}' inserted no row, so there is nothing to attach.`
+            );
+          }
+          patch[plan.localColPropName] = created[plan.foreignColPropName];
+        } else if (op["connect"] !== void 0) {
+          const rows = await executor.select().from(plan.targetTable).where(conditionOf(plan, op["connect"], "connect"));
+          if (rows.length !== 1) {
+            throw new import_graphql7.GraphQLError(
+              `Drizzle-GraphQL Error: 'connect' on '${relationName}' matched ${rows.length} rows \u2014 it attaches a single row, so its filter must match exactly one.`
+            );
+          }
+          patch[plan.localColPropName] = rows[0][plan.foreignColPropName];
+        } else if (op["disconnect"] === true) {
+          patch[plan.localColPropName] = null;
+        }
+      }
+      return patch;
+    },
+    applyChildSide: async (executor, tableName, ops, parentRows) => {
+      const tablePlans = plans[tableName];
+      if (!tablePlans) {
+        return;
+      }
+      for (const [relationName, op] of Object.entries(ops)) {
+        const plan = tablePlans[relationName];
+        if (!plan || plan.fkSide !== "child") {
+          continue;
+        }
+        if (plan.isOne) {
+          assertSingleOperation(plan, op);
+        }
+        for (const parentRow of parentRows) {
+          const key = parentRow?.[plan.localColPropName];
+          if (key === void 0 || key === null) {
+            throw new import_graphql7.GraphQLError(
+              `Drizzle-GraphQL Error: cannot write through '${relationName}': the ${tableName} row has no '${plan.localColPropName}' value to attach to.`
+            );
+          }
+          if (op["set"] !== void 0) {
+            await detachAll(executor, plan, key);
+            for (const filter of asArray(op["set"])) {
+              await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "set"));
+            }
+          }
+          if (op["disconnect"] !== void 0) {
+            if (plan.isOne) {
+              if (op["disconnect"] === true) {
+                await detachAll(executor, plan, key);
+              }
+            } else {
+              for (const filter of asArray(op["disconnect"])) {
+                await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: null }).where((0, import_drizzle_orm6.and)((0, import_drizzle_orm6.eq)(plan.foreignCol, key), conditionOf(plan, filter, "disconnect")));
+              }
+            }
+          }
+          const attaches = op["connect"] !== void 0 || op["create"] !== void 0;
+          if (plan.isOne && attaches && plan.canDetach && op["set"] === void 0) {
+            await detachAll(executor, plan, key);
+          }
+          if (op["connect"] !== void 0) {
+            for (const filter of asArray(op["connect"])) {
+              await executor.update(plan.targetTable).set({ [plan.foreignColPropName]: key }).where(conditionOf(plan, filter, "connect"));
+            }
+          }
+          if (op["create"] !== void 0) {
+            const rows = asArray(op["create"]).map((row) => ({
+              ...remapFromGraphQLSingleInput({ ...row }, plan.targetTable),
+              [plan.foreignColPropName]: key
+            }));
+            if (rows.length) {
+              await executor.insert(plan.targetTable).values(rows);
+            }
+          }
+        }
       }
     }
-    if (Object.keys(relResolvers).length > 0) {
-      fieldResolvers[tableName] = relResolvers;
+  };
+};
+var writeWithNestedOps = async (params) => {
+  const { executor, runtime, tableName, entries, remapValues, write } = params;
+  return executor.transaction(async (tx) => {
+    const rows = [];
+    for (const entry of entries) {
+      const patch = await runtime.applyParentSide(tx, tableName, entry.ops);
+      const written = await write(tx, { ...remapValues(entry.columns), ...patch });
+      await runtime.applyChildSide(tx, tableName, entry.ops, written);
+      rows.push(...written);
     }
-  }
-  return { queries, mutations, inputs, types: outputs, fieldResolvers };
+    return rows;
+  });
+};
+var updateWithNestedOps = async (params) => {
+  const { executor, runtime, tableName, columns, ops, remapValues, write } = params;
+  return executor.transaction(async (tx) => {
+    const patch = await runtime.applyParentSide(tx, tableName, ops);
+    const rows = await write(tx, { ...remapValues(columns), ...patch });
+    await runtime.applyChildSide(tx, tableName, ops, rows);
+    return rows;
+  });
 };
 
 // src/util/builders/pg.ts
-var import_drizzle_orm6 = require("drizzle-orm");
-var import_pg_core2 = require("drizzle-orm/pg-core");
-var import_graphql7 = require("graphql");
-var import_graphql_parse_resolve_info3 = require("graphql-parse-resolve-info");
 var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true) => {
   const queryBase = db.query[tableName];
   const table = tables[tableName];
@@ -3775,24 +4327,24 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
         let cursorEntries;
         if (after != null || cursorSelected) {
           if (after != null && distinct?.length) {
-            throw new import_graphql7.GraphQLError("'after' cannot be combined with 'distinct'.");
+            throw new import_graphql8.GraphQLError("'after' cannot be combined with 'distinct'.");
           }
           if (orderByHasRelationEntry(orderBy)) {
             if (after != null) {
-              throw new import_graphql7.GraphQLError(
+              throw new import_graphql8.GraphQLError(
                 "'after' cannot be combined with an orderBy that orders through a relation \u2014 a related row's value cannot be encoded into a cursor."
               );
             }
           } else if (!pkNames.length) {
             if (after != null) {
-              throw new import_graphql7.GraphQLError(
+              throw new import_graphql8.GraphQLError(
                 `Table ${tableName} has no primary key, so cursor pagination cannot be used on it.`
               );
             }
           } else {
             cursorEntries = cursorOrderingEntries(orderBy, pkNames);
             if (cursorSelected) {
-              const allColumns = (0, import_drizzle_orm6.getColumns)(table);
+              const allColumns = (0, import_drizzle_orm7.getColumns)(table);
               for (const [column] of cursorEntries) {
                 selectedColumnsSql[column] ??= allColumns[column];
               }
@@ -3801,7 +4353,7 @@ var generateSelectArray2 = (db, tableName, tables, relationMap, orderArgs, filte
         }
         const cursorCondition = after != null && cursorEntries ? buildCursorCondition(table, cursorEntries, decodeCursor(after, cursorEntries), "nulls-largest") : void 0;
         const baseWhereSql = where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0;
-        const whereSql = cursorCondition ? (0, import_drizzle_orm6.and)(baseWhereSql, cursorCondition) : baseWhereSql;
+        const whereSql = cursorCondition ? (0, import_drizzle_orm7.and)(baseWhereSql, cursorCondition) : baseWhereSql;
         let distinctKeys;
         if (distinct?.length) {
           distinctKeys = await selectDistinctKeys({
@@ -3912,10 +4464,10 @@ var generateSelectSingle2 = (db, tableName, tables, relationMap, orderArgs, filt
   };
 };
 var pgPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, import_pg_core2.getTableConfig);
-var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx) => {
+var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested) => {
   const queryArgs = {
     values: {
-      type: new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(baseType)))
+      type: new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(baseType)))
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -3924,10 +4476,12 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
     resolver: async (_source, args, context, info) => {
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
-          const input = remapFromGraphQLArrayInput(args.values, table);
-          if (!input.length) {
-            throw new import_graphql7.GraphQLError("No values were provided!");
+          if (!args.values.length) {
+            throw new import_graphql8.GraphQLError("No values were provided!");
           }
+          const entries = nested?.enabled(tableName) ? args.values.map((values) => nested.split(tableName, values)) : void 0;
+          const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
+          const input = nestedEntries ? [] : remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : args.values, table);
           const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
             deep: true
           });
@@ -3941,11 +4495,22 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
             pkNames,
             parsedInfo
           });
-          let query = executor.insert(table).values(input).returning(columns);
-          if (conflictDoNothing) {
-            query = query.onConflictDoNothing();
-          }
-          const result = await query;
+          const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
+          const runInsert = async (target, values) => {
+            let query = target.insert(table).values(values).returning(returning);
+            if (conflictDoNothing) {
+              query = query.onConflictDoNothing();
+            }
+            return await query;
+          };
+          const result = nestedEntries ? await writeWithNestedOps({
+            executor,
+            runtime: nested,
+            tableName,
+            entries: nestedEntries,
+            remapValues: (values) => remapFromGraphQLSingleInput(values, table),
+            write: (tx, values) => runInsert(tx, [values])
+          }) : await runInsert(executor, input);
           const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
           return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
         });
@@ -3956,10 +4521,10 @@ var generateInsertArray2 = (db, tableName, table, tables, relationMap, baseType,
     args: queryArgs
   };
 };
-var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx) => {
+var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested) => {
   const queryArgs = {
     values: {
-      type: new import_graphql7.GraphQLNonNull(baseType)
+      type: new import_graphql8.GraphQLNonNull(baseType)
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -3968,7 +4533,9 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
     resolver: async (_source, args, context, info) => {
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
-          const input = remapFromGraphQLSingleInput(args.values, table);
+          const entry = nested?.enabled(tableName) ? nested.split(tableName, args.values) : void 0;
+          const nestedEntry = entry && nested.hasOps(entry.ops) ? entry : void 0;
+          const input = nestedEntry ? {} : remapFromGraphQLSingleInput(entry ? entry.columns : args.values, table);
           const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
             deep: true
           });
@@ -3982,11 +4549,22 @@ var generateInsertSingle2 = (db, tableName, table, tables, relationMap, baseType
             pkNames,
             parsedInfo
           });
-          let query = executor.insert(table).values(input).returning(columns);
-          if (conflictDoNothing) {
-            query = query.onConflictDoNothing();
-          }
-          const result = await query;
+          const returning = nestedEntry ? nested.withJoinColumns(tableName, nestedEntry.ops, { ...columns }, table) : columns;
+          const runInsert = async (target, values) => {
+            let query = target.insert(table).values(values).returning(returning);
+            if (conflictDoNothing) {
+              query = query.onConflictDoNothing();
+            }
+            return await query;
+          };
+          const result = nestedEntry ? await writeWithNestedOps({
+            executor,
+            runtime: nested,
+            tableName,
+            entries: [nestedEntry],
+            remapValues: (values) => remapFromGraphQLSingleInput(values, table),
+            write: runInsert
+          }) : await runInsert(executor, input);
           if (!result[0]) {
             return void 0;
           }
@@ -4000,10 +4578,10 @@ 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, txCtx) => {
+var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx, nested) => {
   const queryArgs = {
     values: {
-      type: single ? new import_graphql7.GraphQLNonNull(baseType) : new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(baseType)))
+      type: single ? new import_graphql8.GraphQLNonNull(baseType) : new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(baseType)))
     },
     onConflict: {
       type: onConflictType,
@@ -4016,10 +4594,13 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
     resolver: async (_source, args, context, info) => {
       try {
         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 import_graphql7.GraphQLError("No values were provided!");
+          const supplied = single ? [args.values] : args.values;
+          if (!supplied.length) {
+            throw new import_graphql8.GraphQLError("No values were provided!");
           }
+          const entries = nested?.enabled(tableName) ? supplied.map((values) => nested.split(tableName, values)) : void 0;
+          const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
+          const input = nestedEntries ? [] : remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table);
           const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, { deep: true });
           const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
             relationMap,
@@ -4031,19 +4612,30 @@ var generateUpsert2 = (db, tableName, table, tables, relationMap, baseType, onCo
             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;
+          const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
+          const runUpsert = async (target, values) => {
+            const plan = resolveConflictPlan({
+              table,
+              values,
+              onConflict: args.onConflict,
+              pkNames,
+              uniqueSets,
+              excludedRef: excludedColumnRef,
+              withTarget: true,
+              buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
+            });
+            let query = target.insert(table).values(values).returning(returning);
+            query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
+            return await query;
+          };
+          const result = nestedEntries ? await writeWithNestedOps({
+            executor,
+            runtime: nested,
+            tableName,
+            entries: nestedEntries,
+            remapValues: (values) => remapFromGraphQLSingleInput(values, table),
+            write: (tx, values) => runUpsert(tx, [values])
+          }) : await runUpsert(executor, input);
           if (single && !result[0]) {
             return void 0;
           }
@@ -4057,13 +4649,13 @@ 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, txCtx) => {
+var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx, nested) => {
   const queryArgs = {
     set: {
-      type: new import_graphql7.GraphQLNonNull(setArgs)
+      type: new import_graphql8.GraphQLNonNull(setArgs)
     },
     where: {
-      type: single || requireWhere ? new import_graphql7.GraphQLNonNull(filterArgs) : filterArgs
+      type: single || requireWhere ? new import_graphql8.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -4086,23 +4678,37 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
             pkNames,
             parsedInfo
           });
-          const input = remapFromGraphQLSingleInput(set, table);
-          if (!Object.keys(input).length) {
-            throw new import_graphql7.GraphQLError("Unable to update with no values specified!");
+          const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
+          const nestedOps = entry && nested.hasOps(entry.ops) ? entry.ops : void 0;
+          const input = remapFromGraphQLSingleInput(entry ? entry.columns : set, table);
+          if (!Object.keys(input).length && !nestedOps) {
+            throw new import_graphql8.GraphQLError("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;
+          const returning = nestedOps ? nested.withJoinColumns(tableName, nestedOps, { ...columns }, table) : columns;
+          const runUpdate = async (target, values) => {
+            const writes = Object.keys(values).length > 0;
+            let query = writes ? target.update(table).set(values) : target.select(returning).from(table);
+            if (filters) {
+              query = query.where(filters);
+            }
+            return await (writes ? query.returning(returning) : query);
+          };
+          const result = nestedOps ? await updateWithNestedOps({
+            executor,
+            runtime: nested,
+            tableName,
+            columns: input,
+            ops: nestedOps,
+            remapValues: (values) => values,
+            write: runUpdate
+          }) : await runUpdate(executor, input);
           if (single && result.length > 1) {
-            throw new import_graphql7.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
+            throw new import_graphql8.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
           }
           if (single && !result[0]) {
             return void 0;
@@ -4117,10 +4723,10 @@ var generateUpdate2 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
-var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx) => {
+var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx, nested) => {
   const queryArgs = {
     updates: {
-      type: new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(updateManyInput)))
+      type: new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(updateManyInput)))
     }
   };
   const pkNames = pgPrimaryKeyPropNames(table);
@@ -4131,7 +4737,7 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const { updates } = args;
           if (!updates.length) {
-            throw new import_graphql7.GraphQLError("No updates were provided!");
+            throw new import_graphql8.GraphQLError("No updates were provided!");
           }
           const parsedInfo = (0, import_graphql_parse_resolve_info3.parseResolveInfo)(info, {
             deep: true
@@ -4147,23 +4753,40 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
             parsedInfo
           });
           const entries = updates.map(({ where, set }) => {
-            const input = remapFromGraphQLSingleInput(set, table);
-            if (!Object.keys(input).length) {
-              throw new import_graphql7.GraphQLError("Unable to update with no values specified!");
+            const split = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
+            const ops = split && nested.hasOps(split.ops) ? split.ops : void 0;
+            const input = remapFromGraphQLSingleInput(split ? split.columns : set, table);
+            if (!Object.keys(input).length && !ops) {
+              throw new import_graphql8.GraphQLError("Unable to update with no values specified!");
             }
             return {
               set: input,
+              ops,
               filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
             };
           });
+          const returning = entries.some((entry) => entry.ops) ? nested.withJoinColumns(
+            tableName,
+            mergedOps(entries.map((entry) => ({ ops: entry.ops ?? {} }))),
+            {
+              ...columns
+            },
+            table
+          ) : columns;
           const perEntry = await executor.transaction(async (tx) => {
             const results = [];
             for (const entry of entries) {
-              let query = tx.update(table).set(entry.set);
+              const values = entry.ops ? { ...entry.set, ...await nested.applyParentSide(tx, tableName, entry.ops) } : entry.set;
+              const writes = Object.keys(values).length > 0;
+              let query = writes ? tx.update(table).set(values) : tx.select(returning).from(table);
               if (entry.filters) {
                 query = query.where(entry.filters);
               }
-              results.push(await query.returning(columns));
+              const rows = await (writes ? query.returning(returning) : query);
+              if (entry.ops) {
+                await nested.applyChildSide(tx, tableName, entry.ops, rows);
+              }
+              results.push(rows);
             }
             return results;
           });
@@ -4193,7 +4816,7 @@ var generateUpdateMany2 = (db, tableName, table, tables, relationMap, updateMany
 var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx) => {
   const queryArgs = {
     where: {
-      type: single || requireWhere ? new import_graphql7.GraphQLNonNull(filterArgs) : filterArgs
+      type: single || requireWhere ? new import_graphql8.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   return {
@@ -4222,7 +4845,7 @@ var generateDelete2 = (db, tableName, table, filterArgs, fieldName, typeName, si
           query = query.returning(columns);
           const result = await query;
           if (single && result.length > 1) {
-            throw new import_graphql7.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
+            throw new import_graphql8.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
           }
           if (single) {
             return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
@@ -4248,13 +4871,15 @@ function generateSchemaData2(db, schema, relations, options) {
     complexity
   } = options;
   const schemaEntries = Object.entries(schema);
-  const tableEntries = schemaEntries.filter(([_key, value]) => (0, import_drizzle_orm6.is)(value, import_pg_core2.PgTable));
+  const tableEntries = schemaEntries.filter(([_key, value]) => (0, import_drizzle_orm7.is)(value, import_pg_core2.PgTable));
   const tables = Object.fromEntries(tableEntries);
   if (!tableEntries.length) {
     throw new Error(
       "Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?"
     );
   }
+  registerScalarOverrides(tables, options);
+  registerEnumConfig(options);
   const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
   attachTargetPrimaryKeys(namedRelations, tables, pgPrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
@@ -4266,12 +4891,24 @@ 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(),
     aggregateTypeCache: /* @__PURE__ */ new Map(),
-    complexity
+    complexity,
+    docs: options.docs ?? {}
   };
+  const nestedPlans = features.nestedWrites ? buildNestedWritePlans(
+    tables,
+    namedRelations,
+    (target) => getUniqueColumnSets(target, import_pg_core2.getTableConfig),
+    (target) => pgPrimaryKeyPropNames(target),
+    extractRelationJoinColumns
+  ) : void 0;
+  const nestedTypes = nestedPlans ? createNestedWriteTypes({ plans: nestedPlans, cacheCtx, typeNameMapper, insertPrefix: prefixes.insert }) : void 0;
+  const nestedRuntime = nestedPlans ? createNestedWriteRuntime({ plans: nestedPlans, filterCtx }) : void 0;
   const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
@@ -4290,7 +4927,8 @@ function generateSchemaData2(db, schema, relations, options) {
         prefixes.insert,
         prefixes.update,
         resolverFactory,
-        relationAggregateFactory
+        relationAggregateFactory,
+        nestedTypes
       )
     ])
   );
@@ -4351,7 +4989,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeName,
       typeNameMapper,
       conflictDoNothing,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const insertSingleGenerated = features.insert ? generateInsertSingle2(
       db,
@@ -4364,7 +5003,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeName,
       typeNameMapper,
       conflictDoNothing,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], import_pg_core2.getTableConfig) : [];
     const onConflictInput = features.upsert ? generateOnConflictInput({
@@ -4388,7 +5028,8 @@ function generateSchemaData2(db, schema, relations, options) {
       false,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const upsertSingleGenerated = onConflictInput ? generateUpsert2(
       db,
@@ -4404,7 +5045,8 @@ function generateSchemaData2(db, schema, relations, options) {
       true,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const updateGenerated = features.update ? generateUpdate2(
       db,
@@ -4420,7 +5062,8 @@ function generateSchemaData2(db, schema, relations, options) {
       features.requireWhere,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const updateSingleGenerated = features.update ? generateUpdate2(
       db,
@@ -4436,7 +5079,8 @@ function generateSchemaData2(db, schema, relations, options) {
       features.requireWhere,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const updateManyInput = features.update && features.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
     const updateManyGenerated = updateManyInput ? generateUpdateMany2(
@@ -4450,7 +5094,8 @@ function generateSchemaData2(db, schema, relations, options) {
       typeName,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const deleteGenerated = features.delete ? generateDelete2(
       db,
@@ -4515,7 +5160,7 @@ function generateSchemaData2(db, schema, relations, options) {
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
-        type: new import_graphql7.GraphQLNonNull(aggregateType),
+        type: new import_graphql8.GraphQLNonNull(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -4523,7 +5168,7 @@ function generateSchemaData2(db, schema, relations, options) {
     }
     if (groupByGenerated && groupByType) {
       queries[groupByGenerated.name] = {
-        type: new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(new import_graphql7.GraphQLNonNull(groupByType))),
+        type: new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(groupByType))),
         args: groupByGenerated.args,
         resolve: groupByGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -4567,7 +5212,7 @@ function generateSchemaData2(db, schema, relations, options) {
     if (updateManyGenerated) {
       mutations[updateManyGenerated.name] = {
         // Nullable items: a no-match entry yields `null` in its slot.
-        type: new import_graphql7.GraphQLNonNull(new import_graphql7.GraphQLList(singleTableItemOutput)),
+        type: new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(singleTableItemOutput)),
         args: updateManyGenerated.args,
         resolve: updateManyGenerated.resolver
       };
@@ -4624,7 +5269,7 @@ function generateSchemaData2(db, schema, relations, options) {
   for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
     const relResolvers = {};
     for (const [relName, relEntry] of Object.entries(tableRelations)) {
-      const isOne = (0, import_drizzle_orm6.is)(relEntry.relation ?? relEntry, import_drizzle_orm6.One);
+      const isOne = (0, import_drizzle_orm7.is)(relEntry.relation ?? relEntry, import_drizzle_orm7.One);
       const resolver = resolverFactory({ tableName, relationName: relName, relEntry, isOne });
       if (resolver) {
         relResolvers[relName] = resolver;
@@ -4638,9 +5283,9 @@ function generateSchemaData2(db, schema, relations, options) {
 }
 
 // src/util/builders/sqlite.ts
-var import_drizzle_orm7 = require("drizzle-orm");
+var import_drizzle_orm8 = require("drizzle-orm");
 var import_sqlite_core2 = require("drizzle-orm/sqlite-core");
-var import_graphql8 = require("graphql");
+var import_graphql9 = require("graphql");
 var import_graphql_parse_resolve_info4 = require("graphql-parse-resolve-info");
 var generateSelectArray3 = (db, tableName, tables, relationMap, orderArgs, filterArgs, fieldName, typeName, typeNameMapper, filterCtx, distinctEnabled = true) => {
   const queryBase = db.query[tableName];
@@ -4725,10 +5370,10 @@ var generateSelectSingle3 = (db, tableName, tables, relationMap, orderArgs, filt
   };
 };
 var sqlitePrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, import_sqlite_core2.getTableConfig);
-var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx) => {
+var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested) => {
   const queryArgs = {
     values: {
-      type: new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(baseType)))
+      type: new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.GraphQLNonNull(baseType)))
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -4737,10 +5382,12 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
     resolver: async (_source, args, context, info) => {
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
-          const input = remapFromGraphQLArrayInput(args.values, table);
-          if (!input.length) {
-            throw new import_graphql8.GraphQLError("No values were provided!");
+          if (!args.values.length) {
+            throw new import_graphql9.GraphQLError("No values were provided!");
           }
+          const entries = nested?.enabled(tableName) ? args.values.map((values) => nested.split(tableName, values)) : void 0;
+          const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
+          const input = nestedEntries ? [] : remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : args.values, table);
           const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
             deep: true
           });
@@ -4754,11 +5401,22 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
             pkNames,
             parsedInfo
           });
-          let query = executor.insert(table).values(input).returning(columns);
-          if (conflictDoNothing) {
-            query = query.onConflictDoNothing();
-          }
-          const result = await query;
+          const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
+          const runInsert = async (target, values) => {
+            let query = target.insert(table).values(values).returning(returning);
+            if (conflictDoNothing) {
+              query = query.onConflictDoNothing();
+            }
+            return await query;
+          };
+          const result = nestedEntries ? await writeWithNestedOps({
+            executor,
+            runtime: nested,
+            tableName,
+            entries: nestedEntries,
+            remapValues: (values) => remapFromGraphQLSingleInput(values, table),
+            write: (tx, values) => runInsert(tx, [values])
+          }) : await runInsert(executor, input);
           const enriched = hasRelations ? await eagerLoadMutationRelations(executor, tableName, result, pkNames, withParams) : result;
           return remapToGraphQLArrayOutput(enriched, tableName, table, relationMap);
         });
@@ -4769,10 +5427,10 @@ var generateInsertArray3 = (db, tableName, table, tables, relationMap, baseType,
     args: queryArgs
   };
 };
-var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx) => {
+var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType, fieldName, typeName, typeNameMapper, conflictDoNothing = false, txCtx, nested) => {
   const queryArgs = {
     values: {
-      type: new import_graphql8.GraphQLNonNull(baseType)
+      type: new import_graphql9.GraphQLNonNull(baseType)
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -4781,7 +5439,9 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
     resolver: async (_source, args, context, info) => {
       try {
         return await runMutation(db, context, info, txCtx, async (executor) => {
-          const input = remapFromGraphQLSingleInput(args.values, table);
+          const entry = nested?.enabled(tableName) ? nested.split(tableName, args.values) : void 0;
+          const nestedEntry = entry && nested.hasOps(entry.ops) ? entry : void 0;
+          const input = nestedEntry ? {} : remapFromGraphQLSingleInput(entry ? entry.columns : args.values, table);
           const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
             deep: true
           });
@@ -4795,11 +5455,22 @@ var generateInsertSingle3 = (db, tableName, table, tables, relationMap, baseType
             pkNames,
             parsedInfo
           });
-          let query = executor.insert(table).values(input).returning(columns);
-          if (conflictDoNothing) {
-            query = query.onConflictDoNothing();
-          }
-          const result = await query;
+          const returning = nestedEntry ? nested.withJoinColumns(tableName, nestedEntry.ops, { ...columns }, table) : columns;
+          const runInsert = async (target, values) => {
+            let query = target.insert(table).values(values).returning(returning);
+            if (conflictDoNothing) {
+              query = query.onConflictDoNothing();
+            }
+            return await query;
+          };
+          const result = nestedEntry ? await writeWithNestedOps({
+            executor,
+            runtime: nested,
+            tableName,
+            entries: [nestedEntry],
+            remapValues: (values) => remapFromGraphQLSingleInput(values, table),
+            write: runInsert
+          }) : await runInsert(executor, input);
           if (!result[0]) {
             return void 0;
           }
@@ -4813,10 +5484,10 @@ 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, txCtx) => {
+var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onConflictType, uniqueSets, fieldName, typeName, single, typeNameMapper, filterCtx, txCtx, nested) => {
   const queryArgs = {
     values: {
-      type: single ? new import_graphql8.GraphQLNonNull(baseType) : new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(baseType)))
+      type: single ? new import_graphql9.GraphQLNonNull(baseType) : new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.GraphQLNonNull(baseType)))
     },
     onConflict: {
       type: onConflictType,
@@ -4829,10 +5500,13 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
     resolver: async (_source, args, context, info) => {
       try {
         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 import_graphql8.GraphQLError("No values were provided!");
+          const supplied = single ? [args.values] : args.values;
+          if (!supplied.length) {
+            throw new import_graphql9.GraphQLError("No values were provided!");
           }
+          const entries = nested?.enabled(tableName) ? supplied.map((values) => nested.split(tableName, values)) : void 0;
+          const nestedEntries = entries?.some((entry) => nested.hasOps(entry.ops)) ? entries : void 0;
+          const input = nestedEntries ? [] : remapFromGraphQLArrayInput(entries ? entries.map((entry) => entry.columns) : supplied, table);
           const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, { deep: true });
           const { columns, hasRelations, withParams } = prepareMutationRelationColumns({
             relationMap,
@@ -4844,19 +5518,30 @@ var generateUpsert3 = (db, tableName, table, tables, relationMap, baseType, onCo
             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;
+          const returning = nestedEntries ? nested.withJoinColumns(tableName, mergedOps(nestedEntries), { ...columns }, table) : columns;
+          const runUpsert = async (target, values) => {
+            const plan = resolveConflictPlan({
+              table,
+              values,
+              onConflict: args.onConflict,
+              pkNames,
+              uniqueSets,
+              excludedRef: excludedColumnRef,
+              withTarget: true,
+              buildWhere: (where) => extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName))
+            });
+            let query = target.insert(table).values(values).returning(returning);
+            query = plan.action === "NOTHING" ? query.onConflictDoNothing(plan.target ? { target: plan.target } : void 0) : query.onConflictDoUpdate({ target: plan.target, set: plan.set, setWhere: plan.setWhere });
+            return await query;
+          };
+          const result = nestedEntries ? await writeWithNestedOps({
+            executor,
+            runtime: nested,
+            tableName,
+            entries: nestedEntries,
+            remapValues: (values) => remapFromGraphQLSingleInput(values, table),
+            write: (tx, values) => runUpsert(tx, [values])
+          }) : await runUpsert(executor, input);
           if (single && !result[0]) {
             return void 0;
           }
@@ -4870,13 +5555,13 @@ 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, txCtx) => {
+var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filterArgs, fieldName, typeName, single, requireWhere, typeNameMapper, filterCtx, txCtx, nested) => {
   const queryArgs = {
     set: {
-      type: new import_graphql8.GraphQLNonNull(setArgs)
+      type: new import_graphql9.GraphQLNonNull(setArgs)
     },
     where: {
-      type: single || requireWhere ? new import_graphql8.GraphQLNonNull(filterArgs) : filterArgs
+      type: single || requireWhere ? new import_graphql9.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -4899,23 +5584,37 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
             pkNames,
             parsedInfo
           });
-          const input = remapFromGraphQLSingleInput(set, table);
-          if (!Object.keys(input).length) {
-            throw new import_graphql8.GraphQLError("Unable to update with no values specified!");
+          const entry = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
+          const nestedOps = entry && nested.hasOps(entry.ops) ? entry.ops : void 0;
+          const input = remapFromGraphQLSingleInput(entry ? entry.columns : set, table);
+          if (!Object.keys(input).length && !nestedOps) {
+            throw new import_graphql9.GraphQLError("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;
+          const returning = nestedOps ? nested.withJoinColumns(tableName, nestedOps, { ...columns }, table) : columns;
+          const runUpdate = async (target, values) => {
+            const writes = Object.keys(values).length > 0;
+            let query = writes ? target.update(table).set(values) : target.select(returning).from(table);
+            if (filters) {
+              query = query.where(filters);
+            }
+            return await (writes ? query.returning(returning) : query);
+          };
+          const result = nestedOps ? await updateWithNestedOps({
+            executor,
+            runtime: nested,
+            tableName,
+            columns: input,
+            ops: nestedOps,
+            remapValues: (values) => values,
+            write: runUpdate
+          }) : await runUpdate(executor, input);
           if (single && result.length > 1) {
-            throw new import_graphql8.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
+            throw new import_graphql9.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
           }
           if (single && !result[0]) {
             return void 0;
@@ -4930,10 +5629,10 @@ var generateUpdate3 = (db, tableName, table, tables, relationMap, setArgs, filte
     args: queryArgs
   };
 };
-var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx) => {
+var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateManyInput, fieldName, typeName, typeNameMapper, filterCtx, txCtx, nested) => {
   const queryArgs = {
     updates: {
-      type: new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(updateManyInput)))
+      type: new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.GraphQLNonNull(updateManyInput)))
     }
   };
   const pkNames = sqlitePrimaryKeyPropNames(table);
@@ -4944,7 +5643,7 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
         return await runMutation(db, context, info, txCtx, async (executor) => {
           const { updates } = args;
           if (!updates.length) {
-            throw new import_graphql8.GraphQLError("No updates were provided!");
+            throw new import_graphql9.GraphQLError("No updates were provided!");
           }
           const parsedInfo = (0, import_graphql_parse_resolve_info4.parseResolveInfo)(info, {
             deep: true
@@ -4960,23 +5659,55 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
             parsedInfo
           });
           const entries = updates.map(({ where, set }) => {
-            const input = remapFromGraphQLSingleInput(set, table);
-            if (!Object.keys(input).length) {
-              throw new import_graphql8.GraphQLError("Unable to update with no values specified!");
+            const split = nested?.enabled(tableName) ? nested.split(tableName, set) : void 0;
+            const ops = split && nested.hasOps(split.ops) ? split.ops : void 0;
+            const input = remapFromGraphQLSingleInput(split ? split.columns : set, table);
+            if (!Object.keys(input).length && !ops) {
+              throw new import_graphql9.GraphQLError("Unable to update with no values specified!");
             }
             return {
               set: input,
+              ops,
               filters: where ? extractFilters(table, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0
             };
           });
+          const anyNested = entries.some((entry) => entry.ops);
+          const returning = anyNested ? nested.withJoinColumns(
+            tableName,
+            mergedOps(entries.map((entry) => ({ ops: entry.ops ?? {} }))),
+            { ...columns },
+            table
+          ) : columns;
           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();
+            return query.returning(returning).all();
+          };
+          const runNestedEntry = async (tx, entry) => {
+            const values = entry.ops ? { ...entry.set, ...await nested.applyParentSide(tx, tableName, entry.ops) } : entry.set;
+            const writes = Object.keys(values).length > 0;
+            let query = writes ? tx.update(table).set(values) : tx.select(returning).from(table);
+            if (entry.filters) {
+              query = query.where(entry.filters);
+            }
+            const rows = await (writes ? query.returning(returning) : query);
+            if (entry.ops) {
+              await nested.applyChildSide(tx, tableName, entry.ops, rows);
+            }
+            return rows;
           };
           const perEntry = await executor.transaction((tx) => {
+            if (anyNested) {
+              return (async () => {
+                const results2 = [];
+                for (const entry of entries) {
+                  results2.push(await runNestedEntry(tx, entry));
+                }
+                return results2;
+              })();
+            }
             const first = runEntry(tx, entries[0]);
             if (typeof first?.then === "function") {
               return (async () => {
@@ -5019,7 +5750,7 @@ var generateUpdateMany3 = (db, tableName, table, tables, relationMap, updateMany
 var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, single, requireWhere, filterCtx, selectionCtx, txCtx) => {
   const queryArgs = {
     where: {
-      type: single || requireWhere ? new import_graphql8.GraphQLNonNull(filterArgs) : filterArgs
+      type: single || requireWhere ? new import_graphql9.GraphQLNonNull(filterArgs) : filterArgs
     }
   };
   return {
@@ -5048,7 +5779,7 @@ var generateDelete3 = (db, tableName, table, filterArgs, fieldName, typeName, si
           query = query.returning(columns);
           const result = await query;
           if (single && result.length > 1) {
-            throw new import_graphql8.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
+            throw new import_graphql9.GraphQLError(`${fieldName}: 'where' matched more than one row!`);
           }
           if (single) {
             return result[0] ? remapToGraphQLSingleOutput(result[0], tableName, table) : void 0;
@@ -5075,13 +5806,15 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   } = options;
   const rawSchema = schema;
   const schemaEntries = Object.entries(rawSchema);
-  const tableEntries = schemaEntries.filter(([_key, value]) => (0, import_drizzle_orm7.is)(value, import_sqlite_core2.SQLiteTable));
+  const tableEntries = schemaEntries.filter(([_key, value]) => (0, import_drizzle_orm8.is)(value, import_sqlite_core2.SQLiteTable));
   const tables = Object.fromEntries(tableEntries);
   if (!tableEntries.length) {
     throw new Error(
       "Drizzle-GraphQL Error: No tables detected in Drizzle-ORM's database instance. Did you forget to pass schema to drizzle constructor?"
     );
   }
+  registerScalarOverrides(tables, options);
+  registerEnumConfig(options);
   const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
   attachTargetPrimaryKeys(namedRelations, tables, sqlitePrimaryKeyPropNames);
   const eagerRelations = pruneNonEagerRelations(namedRelations, shouldEagerLoad);
@@ -5093,12 +5826,29 @@ 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(),
     aggregateTypeCache: /* @__PURE__ */ new Map(),
-    complexity
+    complexity,
+    docs: options.docs ?? {}
   };
+  if (features.nestedWrites && db.resultKind === "sync") {
+    throw new Error(
+      "Drizzle-GraphQL Error: features.nestedWrites requires an asynchronous SQLite driver (e.g. libsql). Synchronous drivers cannot run the multi-statement transaction a nested write needs."
+    );
+  }
+  const nestedPlans = features.nestedWrites ? buildNestedWritePlans(
+    tables,
+    namedRelations,
+    (target) => getUniqueColumnSets(target, import_sqlite_core2.getTableConfig),
+    (target) => sqlitePrimaryKeyPropNames(target),
+    extractRelationJoinColumns
+  ) : void 0;
+  const nestedTypes = nestedPlans ? createNestedWriteTypes({ plans: nestedPlans, cacheCtx, typeNameMapper, insertPrefix: prefixes.insert }) : void 0;
+  const nestedRuntime = nestedPlans ? createNestedWriteRuntime({ plans: nestedPlans, filterCtx }) : void 0;
   const relationAggregateFactory = features.relationAggregates ? createRelationAggregateFactory(db, tables, cacheCtx, typeNameMapper, filterCtx) : void 0;
   const queries = {};
   const mutations = {};
@@ -5122,7 +5872,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
         prefixes.insert,
         prefixes.update,
         resolverFactory,
-        relationAggregateFactory
+        relationAggregateFactory,
+        nestedTypes
       )
     ])
   );
@@ -5183,7 +5934,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeName,
       typeNameMapper,
       conflictDoNothing,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const insertSingleGenerated = features.insert ? generateInsertSingle3(
       db,
@@ -5196,7 +5948,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeName,
       typeNameMapper,
       conflictDoNothing,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const uniqueSets = features.upsert ? getUniqueColumnSets(schema[tableName], import_sqlite_core2.getTableConfig) : [];
     const onConflictInput = features.upsert ? generateOnConflictInput({
@@ -5220,7 +5973,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       false,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const upsertSingleGenerated = onConflictInput ? generateUpsert3(
       db,
@@ -5236,7 +5990,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       true,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const updateGenerated = features.update ? generateUpdate3(
       db,
@@ -5252,7 +6007,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       features.requireWhere,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const updateSingleGenerated = features.update ? generateUpdate3(
       db,
@@ -5268,7 +6024,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       features.requireWhere,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const updateManyInput = features.update && features.updateMany ? generateUpdateManyInput({ typeName, updatePrefix: prefixes.update, updateInput, tableFilters }) : void 0;
     const updateManyGenerated = updateManyInput ? generateUpdateMany3(
@@ -5282,7 +6039,8 @@ var generateSchemaData3 = (db, schema, relations, options) => {
       typeName,
       typeNameMapper,
       filterCtx,
-      mutationTxCtx
+      mutationTxCtx,
+      nestedRuntime
     ) : void 0;
     const deleteGenerated = features.delete ? generateDelete3(
       db,
@@ -5347,7 +6105,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     };
     if (aggregateGenerated && aggregateType) {
       queries[aggregateGenerated.name] = {
-        type: new import_graphql8.GraphQLNonNull(aggregateType),
+        type: new import_graphql9.GraphQLNonNull(aggregateType),
         args: aggregateGenerated.args,
         resolve: aggregateGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -5355,7 +6113,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     }
     if (groupByGenerated && groupByType) {
       queries[groupByGenerated.name] = {
-        type: new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(new import_graphql8.GraphQLNonNull(groupByType))),
+        type: new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(new import_graphql9.GraphQLNonNull(groupByType))),
         args: groupByGenerated.args,
         resolve: groupByGenerated.resolver,
         ...complexity ? { extensions: { complexity: aggregateFieldComplexity(complexity) } } : {}
@@ -5399,7 +6157,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
     if (updateManyGenerated) {
       mutations[updateManyGenerated.name] = {
         // Nullable items: a no-match entry yields `null` in its slot.
-        type: new import_graphql8.GraphQLNonNull(new import_graphql8.GraphQLList(singleTableItemOutput)),
+        type: new import_graphql9.GraphQLNonNull(new import_graphql9.GraphQLList(singleTableItemOutput)),
         args: updateManyGenerated.args,
         resolve: updateManyGenerated.resolver
       };
@@ -5456,7 +6214,7 @@ var generateSchemaData3 = (db, schema, relations, options) => {
   for (const [tableName, tableRelations] of Object.entries(namedRelations)) {
     const relResolvers = {};
     for (const [relName, relEntry] of Object.entries(tableRelations)) {
-      const isOne = (0, import_drizzle_orm7.is)(relEntry.relation ?? relEntry, import_drizzle_orm7.One);
+      const isOne = (0, import_drizzle_orm8.is)(relEntry.relation ?? relEntry, import_drizzle_orm8.One);
       const resolver = resolverFactory({ tableName, relationName: relName, relEntry, isOne });
       if (resolver) {
         relResolvers[relName] = resolver;
@@ -5501,6 +6259,7 @@ var buildSchema = (db, config) => {
     updateMany: config?.features?.updateMany ?? true,
     delete: config?.features?.delete ?? true,
     upsert: config?.features?.upsert ?? false,
+    nestedWrites: config?.features?.nestedWrites ?? false,
     requireWhere: config?.features?.requireWhere ?? false
   };
   const complexityConfig = config?.complexity ?? true;
@@ -5538,14 +6297,23 @@ var buildSchema = (db, config) => {
     shouldEagerLoad,
     features,
     complexity,
-    transactions
+    scalars: config?.scalars,
+    mapColumnType: config?.mapColumnType,
+    enumNameMapper: config?.enumNameMapper,
+    transactions,
+    docs: {
+      describeColumn: config?.describeColumn,
+      describeTable: config?.describeTable,
+      describeRelation: config?.describeRelation,
+      deprecateColumn: config?.deprecateColumn
+    }
   };
   let generatorOutput;
-  if ((0, import_drizzle_orm8.is)(db, import_mysql_core3.MySqlDatabase)) {
+  if ((0, import_drizzle_orm9.is)(db, import_mysql_core3.MySqlDatabase)) {
     generatorOutput = generateSchemaData(db, schema, relations, generatorOptions);
-  } else if ((0, import_drizzle_orm8.is)(db, import_pg_core3.PgAsyncDatabase)) {
+  } else if ((0, import_drizzle_orm9.is)(db, import_pg_core3.PgAsyncDatabase)) {
     generatorOutput = generateSchemaData2(db, schema, relations, generatorOptions);
-  } else if ((0, import_drizzle_orm8.is)(db, import_sqlite_core3.BaseSQLiteDatabase)) {
+  } else if ((0, import_drizzle_orm9.is)(db, import_sqlite_core3.BaseSQLiteDatabase)) {
     generatorOutput = generateSchemaData3(db, schema, relations, generatorOptions);
   } else {
     throw new Error("Drizzle-GraphQL Error: Unknown database instance type");
@@ -5558,19 +6326,19 @@ var buildSchema = (db, config) => {
   const { queries, mutations, inputs, types } = generatorOutput;
   const graphQLSchemaConfig = {
     types: [...Object.values(inputs), ...Object.values(types)],
-    query: new import_graphql9.GraphQLObjectType({
+    query: new import_graphql10.GraphQLObjectType({
       name: "Query",
       fields: queries
     })
   };
   if (config?.mutations !== false && Object.keys(mutations).length) {
-    const mutation = new import_graphql9.GraphQLObjectType({
+    const mutation = new import_graphql10.GraphQLObjectType({
       name: "Mutation",
       fields: mutations
     });
     graphQLSchemaConfig.mutation = mutation;
   }
-  const outputSchema = new import_graphql9.GraphQLSchema(graphQLSchemaConfig);
+  const outputSchema = new import_graphql10.GraphQLSchema(graphQLSchemaConfig);
   return { schema: outputSchema, entities: generatorOutput };
 };
 // Annotate the CommonJS export names for ESM import in node: