@vantreeseba/drizzle-graphql 9.1.1 → 10.0.1

package/dist/index.js

@@ -1,11 +1,10 @@
-import { Column, One, SQL, Table, aliasedTable, and, arrayContains, arrayOverlaps, asc, avg, count, countDistinct, desc, eq, extractExtendedColumnType, getColumns, getTableAsAliasSQL, getTableColumns, gt, gte, ilike, inArray, is, isNotNull, isNull, like, lt, lte, max, min, ne, not, notIlike, notInArray, notLike, or, relationsFilterToSQL, sql, sum } from "drizzle-orm";
+import { Column, One, SQL, Table, aliasedTable, and, arrayContains, arrayOverlaps, asc, avg, count, countDistinct, desc, eq, extractExtendedColumnType, getColumns, getTableAsAliasSQL, gt, gte, ilike, inArray, is, isNotNull, isNull, like, lt, lte, max, min, ne, not, notIlike, notInArray, notLike, or, relationsFilterToSQL, sql, sum } from "drizzle-orm";
 import { MySqlAsyncDatabase, MySqlInt, MySqlSerial, MySqlTable, getTableConfig } from "drizzle-orm/mysql-core";
 import { PgAsyncDatabase, PgDate, PgDateString, PgInteger, PgSerial, PgTable, PgTimestamp, PgTimestampString, PgUUID, getTableConfig as getTableConfig$1 } from "drizzle-orm/pg-core";
 import { SQLiteAsyncDatabase, SQLiteInteger, SQLiteTable, getTableConfig as getTableConfig$2 } from "drizzle-orm/sqlite-core";
-import { GraphQLBoolean, GraphQLEnumType, GraphQLError, GraphQLFloat, GraphQLInputObjectType, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLScalarType, GraphQLSchema, GraphQLString, Kind } from "graphql";
-import pluralize from "pluralize";
+import { GraphQLBoolean, GraphQLEnumType, GraphQLError, GraphQLFloat, GraphQLInputObjectType, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLScalarType, GraphQLSchema, GraphQLString, Kind, getArgumentValues } from "graphql";
 import { GraphQLDate, GraphQLDateTime, GraphQLJSON, GraphQLUUID } from "graphql-scalars";
-import { parseResolveInfo } from "graphql-parse-resolve-info";
+import pluralize from "pluralize";
 //#region src/util/builders/common/errors.ts
 /**
 * A `GraphQLError` carrying its context as data. The message says what went wrong, in prose
@@ -92,28 +91,6 @@ const applyErrorMapper = (entities, mapError) => {
 	for (const tableResolvers of Object.values(entities.fieldResolvers ?? {})) for (const [relationName, resolve] of Object.entries(tableResolvers)) tableResolvers[relationName] = wrap(resolve);
 };
 //#endregion
-//#region src/util/case-ops/index.ts
-const uncapitalize = (input) => input?.length ? `${input[0].toLocaleLowerCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
-const capitalize = (input) => input?.length ? `${input[0].toLocaleUpperCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
-/**
-* The `typeNameMapper` preset behind `typeNameMapper: 'singularize'`.
-*
-* Derives the singular and plural forms of a table key with the library's own `pluralize`,
-* which is what nearly every consumer with plural table keys (`export const tasks =
-* pgTable('tasks', …)`) was writing by hand — and adding `pluralize` to their own
-* dependencies to write.
-*
-* `tasks` becomes type `Task`, queries `tasks` / `task`, mutations `createTasks` /
-* `createTask`. A key that is already singular is pluralized for the list side, so `task`
-* yields the same names, and a capitalized key (`Tasks`) yields them too — the field forms
-* are uncapitalized so the generated names follow GraphQL's camelCase convention whatever
-* the schema key looks like. The type name is capitalized by the generator either way.
-*/
-const singularizeMapper = (tableName) => ({
-	singular: uncapitalize(pluralize.singular(tableName)),
-	plural: uncapitalize(pluralize.plural(tableName))
-});
-//#endregion
 //#region src/util/scalars/index.ts
 const INVALID_INPUT = "DRIZZLE_INVALID_INPUT_VALUE";
 const UNREPRESENTABLE = "DRIZZLE_UNREPRESENTABLE_VALUE";
@@ -184,6 +161,28 @@ const GraphQLDecimalString = new GraphQLScalarType({
 	}
 });
 //#endregion
+//#region src/util/case-ops/index.ts
+const uncapitalize = (input) => input?.length ? `${input[0].toLocaleLowerCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
+const capitalize = (input) => input?.length ? `${input[0].toLocaleUpperCase()}${input.length > 1 ? input.slice(1, input.length) : ""}` : input;
+/**
+* The `typeNameMapper` preset behind `typeNameMapper: 'singularize'`.
+*
+* Derives the singular and plural forms of a table key with the library's own `pluralize`,
+* which is what nearly every consumer with plural table keys (`export const tasks =
+* pgTable('tasks', …)`) was writing by hand — and adding `pluralize` to their own
+* dependencies to write.
+*
+* `tasks` becomes type `Task`, queries `tasks` / `task`, mutations `createTasks` /
+* `createTask`. A key that is already singular is pluralized for the list side, so `task`
+* yields the same names, and a capitalized key (`Tasks`) yields them too — the field forms
+* are uncapitalized so the generated names follow GraphQL's camelCase convention whatever
+* the schema key looks like. The type name is capitalized by the generator either way.
+*/
+const singularizeMapper = (tableName) => ({
+	singular: uncapitalize(pluralize.singular(tableName)),
+	plural: uncapitalize(pluralize.plural(tableName))
+});
+//#endregion
 //#region src/util/type-converter/index.ts
 const allowedNameChars = /^[a-zA-Z0-9_]+$/;
 /**
@@ -413,7 +412,7 @@ const normalizeScalarOverride = (override, tableName, columnName) => {
 * leaves the column on built-in detection.
 */
 const registerScalarOverrides = (tables, config) => {
-	for (const [tableName, table] of Object.entries(tables)) for (const [columnName, column] of Object.entries(getTableColumns(table))) {
+	for (const [tableName, table] of Object.entries(tables)) for (const [columnName, column] of Object.entries(getColumns(table))) {
 		const declared = config.scalars?.[tableName]?.[columnName];
 		let resolved;
 		if (declared !== void 0) resolved = normalizeScalarOverride(declared, tableName, columnName);
@@ -452,136 +451,6 @@ const drizzleColumnToGraphQLType = (column, columnName, tableName, forceNullable
 	return typeDesc;
 };
 //#endregion
-//#region src/util/data-mappers/index.ts
-const isJsonColumn$1 = (column) => (column.dataType ?? "").includes("json") && column.columnType !== "PgGeometryObject";
-const remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
-	if (Array.isArray(value)) {
-		const relations = relationMap?.[tableName];
-		if (relations?.[key]) {
-			const rel = relations[key];
-			return remapToGraphQLArrayOutput(value, rel.targetTableName, rel.relation?.targetTable ?? rel.relation?.referencedTable, relationMap);
-		}
-	}
-	if (typeof value === "object" && value !== null) {
-		const relations = relationMap?.[tableName];
-		if (relations?.[key]) {
-			const rel = relations[key];
-			return remapToGraphQLSingleOutput(value, rel.targetTableName, rel.relation?.targetTable ?? rel.relation?.referencedTable, relationMap);
-		}
-	}
-	if (!column) return value;
-	if (getColumnScalarOverride(column, false)) return value;
-	if (isJsonColumn$1(column)) return value;
-	if (value instanceof Date) return value.toISOString();
-	if (value instanceof Buffer) return Array.from(value);
-	if (typeof value === "bigint") return value.toString();
-	if (Array.isArray(value)) {
-		if (column.columnType === "PgGeometry" || column.columnType === "PgVector") return value;
-		return value.map((arrVal) => remapToGraphQLCore(key, arrVal, tableName, column, relationMap));
-	}
-	if (typeof value === "object" && value !== null) {
-		if (column.columnType === "PgGeometryObject") return value;
-		return JSON.stringify(value);
-	}
-	return value;
-};
-const remapToGraphQLSingleOutput = (queryOutput, tableName, table, relationMap) => {
-	const columns = getTableColumns(table);
-	for (const [key, value] of Object.entries(queryOutput)) {
-		if (value === void 0 || value === null) {
-			const relEntry = value === null ? relationMap?.[tableName]?.[key] : void 0;
-			if (relEntry && is(relEntry.relation, One)) {
-				queryOutput[key] = null;
-				continue;
-			}
-			delete queryOutput[key];
-			continue;
-		}
-		const column = columns[key];
-		if (value === 0n && column && column.columnType === "SQLiteBigInt" && !column.notNull) {
-			delete queryOutput[key];
-			continue;
-		}
-		queryOutput[key] = remapToGraphQLCore(key, value, tableName, column, relationMap);
-	}
-	return queryOutput;
-};
-const remapToGraphQLArrayOutput = (queryOutput, tableName, table, relationMap) => {
-	for (const entry of queryOutput) remapToGraphQLSingleOutput(entry, tableName, table, relationMap);
-	return queryOutput;
-};
-const 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 ?? "";
-	if (columnType === "SQLiteTimestamp" || columnType === "SQLiteTimestampMs" || columnType === "MySqlTimestamp" || columnType === "MySqlDateTime" || columnType === "PgTimestamp" || columnType === "PgTimestampString") {
-		const formatted = new Date(value);
-		if (Number.isNaN(formatted.getTime())) throw drizzleError(`Field '${columnName}' is not a valid date!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
-		return formatted;
-	}
-	if ((columnType === "MySqlDate" || columnType === "PgDate") && typeof value === "string") {
-		const dateOnly = value.includes("T") ? value.split("T")[0] : value;
-		const check = new Date(dateOnly);
-		if (Number.isNaN(check.getTime())) throw drizzleError(`Field '${columnName}' is not a valid date!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
-		return dateOnly;
-	}
-	if (dataType.includes("bigint")) try {
-		return BigInt(value);
-	} catch {
-		throw drizzleError(`Field '${columnName}' is not a BigInt!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
-	}
-	if (dataType.includes("json") && column.columnType !== "PgGeometryObject") return value;
-	switch (dataType) {
-		case "date": {
-			const formatted = new Date(value);
-			if (Number.isNaN(formatted.getTime())) throw drizzleError(`Field '${columnName}' is not a valid date!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
-			return formatted;
-		}
-		case "buffer":
-			if (!Array.isArray(value)) throw drizzleError(`Field '${columnName}' is not an array!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
-			return Buffer.from(value);
-		case "json":
-			if (column.columnType === "PgGeometryObject") return value;
-			try {
-				return JSON.parse(value);
-			} catch (e) {
-				throw drizzleError(`Invalid JSON in field '${columnName}':\n${e instanceof Error ? e.message : "Unknown error"}`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
-			}
-		case "array":
-			if (!Array.isArray(value)) throw drizzleError(`Field '${columnName}' is not an array!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
-			if (column.columnType === "PgGeometry" && value.length !== 2) throw drizzleError(`Invalid float tuple in field '${columnName}': expected array with length of 2, received ${value.length}`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
-			return value;
-		case "bigint": try {
-			return BigInt(value);
-		} catch (_error) {
-			throw drizzleError(`Field '${columnName}' is not a BigInt!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
-		}
-		default:
-			if (typeof value === "object" && value !== null && Object.getPrototypeOf(value) === null) return Object.assign({}, value);
-			return value;
-	}
-};
-const remapFromGraphQLSingleInput = (queryInput, table) => {
-	for (const [key, value] of Object.entries(queryInput)) if (value === void 0) delete queryInput[key];
-	else {
-		const column = getTableColumns(table)[key];
-		if (!column) throw drizzleError(`Unknown column: ${key}`, { code: "DRIZZLE_UNKNOWN_COLUMN" });
-		if (value === null && column.notNull) {
-			delete queryInput[key];
-			continue;
-		}
-		queryInput[key] = remapFromGraphQLCore(value, column, key);
-	}
-	return queryInput;
-};
-const remapFromGraphQLArrayInput = (queryInput, table) => {
-	for (const entry of queryInput) remapFromGraphQLSingleInput(entry, table);
-	return queryInput;
-};
-//#endregion
 //#region src/util/builders/common/type-names.ts
 /**
 * The build's naming rule: the mapper's answer where it has one, otherwise the default name
@@ -624,6 +493,23 @@ const columnDialect = (column) => {
 	if (ct.startsWith("SQLite")) return "sqlite";
 };
 /**
+* Whether the column stores JSON.
+*
+* Decided on drizzle's `dataType`, its semantic marker, rather than on `columnType`, which
+* names the implementing class. drizzle-orm v1 uses compound dataType strings (`"object
+* json"` for every json/jsonb column across the three dialects), hence the inclusion test.
+*
+* `PgGeometryObject` is excluded explicitly. That is currently redundant — it reports
+* `"object geometry"` — but it is stored as json, has its own object type in the generated
+* schema, and must not be reclassified if drizzle ever spells its dataType differently.
+*
+* One predicate for two callers that must agree: the filter builder, whose `path` and
+* `contains` operators mean structural JSON containment rather than the string operators,
+* and the data mappers, which transport a JSON value as-is instead of remapping it. They
+* previously had a copy each, asking different questions of the column.
+*/
+const isJsonColumn = (column) => (column.dataType ?? "").includes("json") && column.columnType !== "PgGeometryObject";
+/**
 * Maps a Drizzle column to the generic filter type to use.
 *
 * Selection is keyed on the column's data type, never its name: a text column named
@@ -1054,6 +940,137 @@ const generateColumnFilterValues = (column, tableName, columnName, cacheCtx) =>
 	return mainType;
 };
 //#endregion
+//#region src/util/data-mappers/index.ts
+const remapToGraphQLCore = (key, value, tableName, column, relationMap) => {
+	if (Array.isArray(value)) {
+		const relations = relationMap?.[tableName];
+		if (relations?.[key]) {
+			const rel = relations[key];
+			return remapToGraphQLArrayOutput(value, rel.targetTableName, rel.relation?.targetTable ?? rel.relation?.referencedTable, relationMap);
+		}
+	}
+	if (typeof value === "object" && value !== null) {
+		const relations = relationMap?.[tableName];
+		if (relations?.[key]) {
+			const rel = relations[key];
+			return remapToGraphQLSingleOutput(value, rel.targetTableName, rel.relation?.targetTable ?? rel.relation?.referencedTable, relationMap);
+		}
+	}
+	if (!column) return value;
+	if (getColumnScalarOverride(column, false)) return value;
+	if (isJsonColumn(column)) return value;
+	if (value instanceof Date) return value.toISOString();
+	if (value instanceof Buffer) return Array.from(value);
+	if (typeof value === "bigint") return value.toString();
+	if (Array.isArray(value)) {
+		if (column.columnType === "PgGeometry" || column.columnType === "PgVector") return value;
+		return value.map((arrVal) => remapToGraphQLCore(key, arrVal, tableName, column, relationMap));
+	}
+	if (typeof value === "object" && value !== null) {
+		if (column.columnType === "PgGeometryObject") return value;
+		return JSON.stringify(value);
+	}
+	return value;
+};
+const remapToGraphQLSingleOutput = (queryOutput, tableName, table, relationMap) => {
+	const columns = getColumns(table);
+	for (const [key, value] of Object.entries(queryOutput)) {
+		if (value === void 0 || value === null) {
+			const relEntry = value === null ? relationMap?.[tableName]?.[key] : void 0;
+			if (relEntry && is(relEntry.relation, One)) {
+				queryOutput[key] = null;
+				continue;
+			}
+			delete queryOutput[key];
+			continue;
+		}
+		const column = columns[key];
+		if (value === 0n && column && column.columnType === "SQLiteBigInt" && !column.notNull) {
+			delete queryOutput[key];
+			continue;
+		}
+		queryOutput[key] = remapToGraphQLCore(key, value, tableName, column, relationMap);
+	}
+	return queryOutput;
+};
+const remapToGraphQLArrayOutput = (queryOutput, tableName, table, relationMap) => {
+	for (const entry of queryOutput) remapToGraphQLSingleOutput(entry, tableName, table, relationMap);
+	return queryOutput;
+};
+const 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 ?? "";
+	if (columnType === "SQLiteTimestamp" || columnType === "SQLiteTimestampMs" || columnType === "MySqlTimestamp" || columnType === "MySqlDateTime" || columnType === "PgTimestamp" || columnType === "PgTimestampString") {
+		const formatted = new Date(value);
+		if (Number.isNaN(formatted.getTime())) throw drizzleError(`Field '${columnName}' is not a valid date!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
+		return formatted;
+	}
+	if ((columnType === "MySqlDate" || columnType === "PgDate") && typeof value === "string") {
+		const dateOnly = value.includes("T") ? value.split("T")[0] : value;
+		const check = new Date(dateOnly);
+		if (Number.isNaN(check.getTime())) throw drizzleError(`Field '${columnName}' is not a valid date!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
+		return dateOnly;
+	}
+	if (dataType.includes("bigint")) try {
+		return BigInt(value);
+	} catch {
+		throw drizzleError(`Field '${columnName}' is not a BigInt!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
+	}
+	if (dataType.includes("json") && column.columnType !== "PgGeometryObject") return value;
+	switch (dataType) {
+		case "date": {
+			const formatted = new Date(value);
+			if (Number.isNaN(formatted.getTime())) throw drizzleError(`Field '${columnName}' is not a valid date!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
+			return formatted;
+		}
+		case "buffer":
+			if (!Array.isArray(value)) throw drizzleError(`Field '${columnName}' is not an array!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
+			return Buffer.from(value);
+		case "json":
+			if (column.columnType === "PgGeometryObject") return value;
+			try {
+				return JSON.parse(value);
+			} catch (e) {
+				throw drizzleError(`Invalid JSON in field '${columnName}':\n${e instanceof Error ? e.message : "Unknown error"}`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
+			}
+		case "array":
+			if (!Array.isArray(value)) throw drizzleError(`Field '${columnName}' is not an array!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
+			if (column.columnType === "PgGeometry" && value.length !== 2) throw drizzleError(`Invalid float tuple in field '${columnName}': expected array with length of 2, received ${value.length}`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
+			return value;
+		case "bigint": try {
+			return BigInt(value);
+		} catch (_error) {
+			throw drizzleError(`Field '${columnName}' is not a BigInt!`, { code: "DRIZZLE_INVALID_INPUT_VALUE" });
+		}
+		default:
+			if (typeof value === "object" && value !== null && Object.getPrototypeOf(value) === null) return Object.assign({}, value);
+			return value;
+	}
+};
+const remapFromGraphQLSingleInput = (queryInput, table, operation = "insert") => {
+	const columns = getColumns(table);
+	for (const [key, value] of Object.entries(queryInput)) if (value === void 0) delete queryInput[key];
+	else {
+		const column = columns[key];
+		if (!column) throw drizzleError(`Unknown column: ${key}`, { code: "DRIZZLE_UNKNOWN_COLUMN" });
+		if (value === null && column.notNull) {
+			if (operation === "update") throw drizzleError(`Column '${key}' cannot be set to null.`, { code: "DRIZZLE_NOT_NULL" });
+			delete queryInput[key];
+			continue;
+		}
+		queryInput[key] = remapFromGraphQLCore(value, column, key);
+	}
+	return queryInput;
+};
+const remapFromGraphQLArrayInput = (queryInput, table, operation = "insert") => {
+	for (const entry of queryInput) remapFromGraphQLSingleInput(entry, table, operation);
+	return queryInput;
+};
+//#endregion
 //#region src/util/builders/common/filters.ts
 /**
 * Escape character pinned via `ESCAPE` on every generated safe-LIKE predicate. Bound as a
@@ -1142,11 +1159,6 @@ const lowerMembership = (column, values, negated) => {
 	return negated ? sql`lower(${column}) not in (${lowered})` : sql`lower(${column}) in (${lowered})`;
 };
 /**
-* Whether the column stores JSON — its `contains` operator is structural containment,
-* not the safe substring operator string columns get.
-*/
-const isJsonColumn = (column) => (column.columnType ?? "").includes("Json");
-/**
 * Structural JSON containment for the `contains` operator on json/jsonb columns.
 * The value is serialized and bound as a parameter (never interpolated into the SQL text):
 * - Postgres: `col @> $1::jsonb` (a plain `json` column is cast through jsonb — `json` has
@@ -1285,36 +1297,37 @@ const jsonPathCondition = (column, columnName, filter) => {
 	}
 	return variants.length ? variants.length > 1 ? and(...variants) : variants[0] : void 0;
 };
+const singleValueOps = {
+	eq,
+	ne,
+	gt,
+	gte,
+	lt,
+	lte
+};
+const stringValueOps = {
+	like,
+	notLike,
+	ilike,
+	notIlike
+};
+const arrayValueOps = {
+	inArray,
+	notInArray
+};
+/** Membership operators for array columns: element list → SQL. Empty lists are rejected below. */
+const arrayMembershipOps = {
+	hasSome: arrayOverlaps,
+	hasEvery: arrayContains
+};
+const nullableOps = {
+	isNull,
+	isNotNull
+};
 const extractFiltersColumn = (column, columnName, operators) => {
 	const { OR, AND, NOT, insensitive, ...restOperators } = operators;
 	const foldCase = insensitive === true;
 	const entries = Object.entries(restOperators);
-	const singleValueOps = {
-		eq,
-		ne,
-		gt,
-		gte,
-		lt,
-		lte
-	};
-	const stringValueOps = {
-		like,
-		notLike,
-		ilike,
-		notIlike
-	};
-	const arrayValueOps = {
-		inArray,
-		notInArray
-	};
-	const arrayMembershipOps = {
-		hasSome: arrayOverlaps,
-		hasEvery: arrayContains
-	};
-	const nullableOps = {
-		isNull,
-		isNotNull
-	};
 	const variants = [];
 	for (const [operatorName, operatorValue] of entries) {
 		if (operatorValue === null || operatorValue === false) continue;
@@ -2145,7 +2158,7 @@ const isFilterableRelation = (relation) => !relation.through;
 * (an object without a `direction`) is rejected with a clear error instead of being
 * silently dropped.
 */
-const orderByEntries = (orderArgs) => Object.entries(orderArgs).sort((a, b) => (b[1]?.priority ?? 0) - (a[1]?.priority ?? 0)).filter(([, config]) => config).map(([column, config]) => {
+const orderByEntries = (orderArgs) => Object.entries(orderArgs).filter(([, config]) => config).sort((a, b) => (b[1]?.priority ?? 0) - (a[1]?.priority ?? 0)).map(([column, config]) => {
 	if (typeof config === "object" && config.direction === void 0) throw drizzleError(`ORDER BY ${column}: ordering through a relation is not supported in this query`, { code: "DRIZZLE_INVALID_ORDER_BY" });
 	if (config.matchFilterOrder) throw drizzleError(`ORDER BY ${column}: 'matchFilterOrder' is not supported in this query`, { code: "DRIZZLE_INVALID_ORDER_BY" });
 	return [
@@ -2331,16 +2344,20 @@ const decodeCursorValue = (value) => {
 	return value;
 };
 /**
-* Encodes a row's position in the given total order as an opaque cursor: base64url of a JSON
-* payload holding the ordering spec (`o`) and the row's values for it (`v`). The spec rides
-* along so a later request can verify the cursor was issued for the same ordering it is using.
-*/
-const encodeCursor = (entries, row) => {
-	const payload = {
-		o: entries,
-		v: entries.map(([column]) => encodeCursorValue(row[column] ?? null))
+* `encodeCursor` bound to one ordering, for encoding a whole page.
+*
+* The ordering spec is the same for every row of a page, so it is serialized once here and
+* spliced into each row's payload rather than re-serialized per row. The bytes are identical
+* to what building the payload object and stringifying it produces — same keys, same order —
+* so cursors stay interchangeable with ones issued before this was split out.
+*/
+const cursorEncoder = (entries) => {
+	const spec = JSON.stringify(entries);
+	const columns = entries.map(([column]) => column);
+	return (row) => {
+		const values = JSON.stringify(columns.map((column) => encodeCursorValue(row[column] ?? null)));
+		return Buffer.from(`{"o":${spec},"v":${values}}`, "utf8").toString("base64url");
 	};
-	return Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
 };
 /**
 * Decodes an `after` cursor and validates it against the ordering the current request pages
@@ -2430,7 +2447,8 @@ const selectsCursorField = (info, table) => {
 * dates and bigints into their transport forms.
 */
 const attachRowCursors = (rows, entries) => {
-	for (const row of rows) row[ROW_CURSOR_PROP] = encodeCursor(entries, row);
+	const encode = cursorEncoder(entries);
+	for (const row of rows) row[ROW_CURSOR_PROP] = encode(row);
 };
 /** Resolver for the `cursor` meta field: reads the value a list resolver attached, if any. */
 const rowCursorResolver = (source) => source?.[ROW_CURSOR_PROP] ?? null;
@@ -2474,6 +2492,31 @@ const withPrimaryKeyColumns = (columns, table, pkNames) => {
 	return columns;
 };
 /**
+* Wraps a dialect's `getTableConfig` in a per-table cache.
+*
+* The dialect implementations are not lookups: each call re-runs the table's
+* `extraConfigBuilder` and rebuilds every index, check, unique constraint, primary key and
+* foreign key it declares. Nothing about a table changes after it is defined, so the result
+* is the same every time — but a build asks for it many times per table (primary-key names,
+* unique column sets, conflict targets, one per relation that keys off the target's PK), and
+* an overriding resolver asks again at request time.
+*
+* The cache is a `WeakMap` on the table object, so it costs nothing once the table is gone.
+* Bind it once per dialect module, at module scope, so the cache outlives a single
+* `buildSchema` call.
+*/
+const memoizeTableConfig = (getTableConfig) => {
+	const cache = /* @__PURE__ */ new WeakMap();
+	return (table) => {
+		let config = cache.get(table);
+		if (config === void 0) {
+			config = getTableConfig(table);
+			cache.set(table, config);
+		}
+		return config;
+	};
+};
+/**
 * Resolves a table's primary-key property names using a dialect's `getTableConfig` to
 * surface table-level composite keys (whose member columns aren't flagged `.primary`).
 * Each dialect builder binds this with its own getTableConfig and reuses the binding for
@@ -2980,10 +3023,14 @@ const splitFieldUpdateOperations = (values, table, tableName) => {
 *
 * Safe to call on every update path regardless of `features.fieldUpdateOperations` — see the
 * shape check in {@link splitFieldUpdateOperations}.
+*
+* This is the single funnel every update goes through — the plural and `Single` mutations,
+* `updateMany`, the `Count` mutations and the MySQL builder's own — which is why it is the
+* one place that has to tell the remapper it is serving an update rather than an insert.
 */
 const remapUpdateInput = (values, table, tableName) => {
 	const { columns, expressions } = splitFieldUpdateOperations(values, table, tableName);
-	const remapped = remapFromGraphQLSingleInput(columns, table);
+	const remapped = remapFromGraphQLSingleInput(columns, table, "update");
 	return Object.keys(expressions).length ? {
 		...remapped,
 		...expressions
@@ -3026,48 +3073,55 @@ const relationJoinColumns = (tree, table, selectionCtx) => {
 	}
 	return needed;
 };
-const extractSelectedColumnsFromTree = (tree, table, selectionCtx) => {
+/**
+* The column the extractors fall back to when a selection names none of its own — a query that
+* asked only for `__typename`, or only for relation fields. The relational query builder still
+* needs at least one column, and some SQLite column types crash it when they are the only one
+* selected, so a column of any other type is preferred and the first column is the last resort.
+*/
+const fallbackColumnName = (tableColumns) => {
+	const columnKeys = Object.entries(tableColumns);
+	return columnKeys.find(([, column]) => !rqbCrashTypes.includes(column.columnType))?.[0] ?? columnKeys[0][0];
+};
+/**
+* Property names of the columns a selection reads: the ones it names itself, plus the join
+* columns its relation fields correlate on, plus the fallback when that leaves nothing.
+*/
+const selectedColumnNames = (tree, table, selectionCtx) => {
 	const tableColumns = getColumns(table);
-	const treeEntries = Object.entries(tree);
-	const selectedColumns = [];
-	for (const [_fieldName, fieldData] of treeEntries) {
+	const names = [];
+	for (const fieldData of Object.values(tree)) {
 		if (!tableColumns[fieldData.name]) continue;
-		selectedColumns.push([fieldData.name, true]);
-	}
-	for (const columnName of relationJoinColumns(tree, table, selectionCtx)) selectedColumns.push([columnName, true]);
-	if (!selectedColumns.length) {
-		const columnKeys = Object.entries(tableColumns);
-		const columnName = columnKeys.find((e) => rqbCrashTypes.find((haram) => e[1].columnType !== haram))?.[0] ?? columnKeys[0][0];
-		selectedColumns.push([columnName, true]);
+		names.push(fieldData.name);
 	}
+	names.push(...relationJoinColumns(tree, table, selectionCtx));
+	if (!names.length) names.push(fallbackColumnName(tableColumns));
+	return names;
+};
+/** The requested columns as the relational query builder's `columns` map. */
+const extractSelectedColumnsFromTree = (tree, table, selectionCtx) => {
+	const selectedColumns = selectedColumnNames(tree, table, selectionCtx).map((columnName) => [columnName, true]);
 	return Object.fromEntries(selectedColumns);
 };
 /**
+* The same columns as a SQL select list.
+*
 * Can't automatically determine column type on type level
 * Since drizzle table types extend eachother
 */
 const extractSelectedColumnsFromTreeSQLFormat = (tree, table, selectionCtx) => {
 	const tableColumns = getColumns(table);
-	const treeEntries = Object.entries(tree);
-	const selectedColumns = [];
-	for (const [_fieldName, fieldData] of treeEntries) {
-		if (!tableColumns[fieldData.name]) continue;
-		selectedColumns.push([fieldData.name, tableColumns[fieldData.name]]);
-	}
-	for (const columnName of relationJoinColumns(tree, table, selectionCtx)) selectedColumns.push([columnName, tableColumns[columnName]]);
-	if (!selectedColumns.length) {
-		const columnKeys = Object.entries(tableColumns);
-		const columnName = columnKeys.find((e) => rqbCrashTypes.find((haram) => e[1].columnType !== haram))?.[0] ?? columnKeys[0][0];
-		selectedColumns.push([columnName, tableColumns[columnName]]);
-	}
+	const selectedColumns = selectedColumnNames(tree, table, selectionCtx).map((columnName) => [columnName, tableColumns[columnName]]);
 	return Object.fromEntries(selectedColumns);
 };
 //#endregion
 //#region src/util/builders/common/relation-params.ts
-const extractRelationsParamsInner = (relationMap, tables, tableName, typeName, originField, typeNameMapper, _isInitial = false, filterCtx, limits, scope, defaultOrderBy, resolveName) => {
+const extractRelationsParams = (relationMap, tables, tableName, info, typeName, options = {}) => {
+	const { typeNameMapper, filterCtx, limits, scope, defaultOrderBy, resolveName } = options;
+	if (!info) return;
 	const relationsForTable = relationMap[tableName];
 	if (!relationsForTable) return;
-	const baseField = Object.entries(originField.fieldsByTypeName).find(([key, _value]) => key === typeName)?.[1];
+	const baseField = Object.entries(info.fieldsByTypeName).find(([key, _value]) => key === typeName)?.[1];
 	if (!baseField) return;
 	const args = {};
 	for (const [relName, relEntry] of Object.entries(relationsForTable)) {
@@ -3104,15 +3158,11 @@ const extractRelationsParamsInner = (relationMap, tables, tableName, typeName, o
 		thisRecord.orderBy = relationArgs?.orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, relationArgs.orderBy, relationFilterCtx(filterCtx, targetTableName), relWhere) : hasPagination && pkNames.length ? (aliasedTable) => primaryKeyOrderExprs(aliasedTable, pkNames) : void 0;
 		thisRecord.offset = offset;
 		thisRecord.limit = limit;
-		thisRecord.with = relationField ? extractRelationsParamsInner(relationMap, tables, targetTableName, relTypeName, relationField, typeNameMapper, false, filterCtx, limits, scope, defaultOrderBy, resolveName) : void 0;
+		thisRecord.with = extractRelationsParams(relationMap, tables, targetTableName, relationField, relTypeName, options);
 		args[relName] = thisRecord;
 	}
 	return args;
 };
-const extractRelationsParams = (relationMap, tables, tableName, info, typeName, typeNameMapper, filterCtx, limits, scope, defaultOrderBy, resolveName) => {
-	if (!info) return;
-	return extractRelationsParamsInner(relationMap, tables, tableName, typeName, info, typeNameMapper, true, filterCtx, limits, scope, defaultOrderBy, resolveName);
-};
 /**
 * Returns a copy of `relationMap` containing only the relations that should be eagerly
 * pre-fetched (per the `shouldEagerLoad` predicate). Pass the result wherever a query or
@@ -3313,7 +3363,13 @@ const hardDeleteArg = {
 const prepareMutationRelationColumns = (params) => {
 	const { relationMap, tables, tableName, typeNameMapper, table, pkNames, parsedInfo, resolveName } = params;
 	const typeName = resolveObjectTypeName(tableName, typeNameMapper, resolveName);
-	const withParams = relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, typeNameMapper, void 0, params.limits, params.scope, params.defaultOrderBy, resolveName) : void 0;
+	const withParams = relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, {
+		typeNameMapper,
+		limits: params.limits,
+		scope: params.scope,
+		defaultOrderBy: params.defaultOrderBy,
+		resolveName
+	}) : void 0;
 	const hasRelations = !!(withParams && Object.keys(withParams).length);
 	const baseColumns = extractSelectedColumnsFromTreeSQLFormat(parsedInfo.fieldsByTypeName[typeName], table, {
 		tableName,
@@ -3892,7 +3948,14 @@ const runRelationalSelect = async (opts) => {
 		offset: distinctKeys ? void 0 : offset,
 		orderBy: distinctKeys ? (aliasedTable) => [...orderBy ? extractOrderBy(aliasedTable, orderBy, relationFilterCtx(filterCtx, tableName), where) : [], ...primaryKeyOrderExprs(aliasedTable, pkNames)] : cursorEntries ? (aliasedTable) => cursorOrderExprs(aliasedTable, cursorEntries) : orderBy ? (aliasedTable) => extractOrderBy(aliasedTable, orderBy, relationFilterCtx(filterCtx, tableName), where) : needsDefaultOrder && pkNames?.length ? (aliasedTable) => primaryKeyOrderExprs(aliasedTable, pkNames) : void 0,
 		where: distinctKeys ? { RAW: (aliasedTable) => primaryKeyRestriction(aliasedTable, pkNames, distinctKeys) } : where || cursorValues || scope?.has(tableName, deleted) ? { RAW: (aliasedTable) => withScope(scope, tableName, aliasedTable, and(where ? extractFilters(aliasedTable, tableName, where, relationFilterCtx(filterCtx, tableName)) : void 0, cursorValues ? buildCursorCondition(aliasedTable, cursorEntries, cursorValues, opts.nullOrdering ?? "nulls-smallest") : void 0), deleted) } : void 0,
-		with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, typeNameMapper, filterCtx, opts.limits, scope, opts.defaultOrderBy, opts.resolveName) : void 0
+		with: relationMap[tableName] ? extractRelationsParams(relationMap, tables, tableName, parsedInfo, typeName, {
+			typeNameMapper,
+			filterCtx,
+			limits: opts.limits,
+			scope,
+			defaultOrderBy: opts.defaultOrderBy,
+			resolveName: opts.resolveName
+		}) : void 0
 	};
 	if (single) {
 		const result = await queryBase.findFirst(params);
@@ -4740,6 +4803,154 @@ const resolveBuildConfig = (config, schema) => {
 	};
 };
 //#endregion
+//#region src/util/parse-resolve-info.ts
+/** Unwraps `[T]!`-style wrappers down to the named type. `getNamedType` without the realm tie. */
+const namedTypeOf = (type) => {
+	let current = type;
+	while (current?.ofType) current = current.ofType;
+	return current;
+};
+/**
+* Whether a field's named output type has sub-selections. Object types and interfaces expose
+* `getFields`, unions expose `getTypes`; scalars and enums expose neither. Input object types
+* also expose `getFields`, but an input type can never be a field's output type, so there is
+* nothing here for that to collide with.
+*/
+const isCompositeLike = (type) => !!type && (typeof type.getFields === "function" || typeof type.getTypes === "function");
+/**
+* The fields declared on a type, or `undefined` when it has none to declare. A union is the
+* case that matters: it has no fields of its own, so a selection directly against one resolves
+* to nothing and is dropped — only the inline fragments underneath contribute.
+*/
+const fieldsOf = (type) => typeof type?.getFields === "function" ? type.getFields() : void 0;
+/**
+* The runtime variable values, in the plain-map form the directive check wants. graphql 17
+* wraps them in `{ sources, coerced }`; graphql 16 hands over the map itself.
+*/
+const coercedVariables = (info) => {
+	const values = info.variableValues;
+	if (values && typeof values === "object" && "coerced" in values) return values.coerced ?? {};
+	return values ?? {};
+};
+/** The value of a `@skip` / `@include` `if:` argument — a literal or a variable reference. */
+const directiveIfValue = (info, value) => {
+	if (value.kind === Kind.VARIABLE) return coercedVariables(info)[value.name.value];
+	if (value.kind === Kind.BOOLEAN) return value.value;
+};
+/**
+* Whether `@skip` / `@include` on this selection exclude it. Applies to fields, fragment
+* spreads and inline fragments alike, which is where graphql puts them.
+*/
+const isExcluded = (info, node) => {
+	for (const directive of node.directives ?? []) {
+		const directiveName = directive.name.value;
+		if (directiveName !== "skip" && directiveName !== "include") continue;
+		const ifArgument = directive.arguments?.find((argument) => argument.name.value === "if");
+		if (!ifArgument) continue;
+		const value = directiveIfValue(info, ifArgument.value);
+		if (directiveName === "skip" ? !!value : !value) return true;
+	}
+	return false;
+};
+/** The type a fragment's `on Type` condition names, looked up in the executing schema. */
+const typeFromCondition = (info, condition) => info.schema.getType(condition.name.value);
+/**
+* Introspection meta-fields are not schema fields and never reach the database. `__typename` is
+* the one that turns up in practice; `__id` is excluded from the rule because a schema is free
+* to declare a field by that name.
+*/
+const isMetaField = (name) => name.startsWith("__") && name !== "__id";
+/**
+* Merges one selection set into `tree`, which is a `fieldsByTypeName` map — the caller owns the
+* level, this owns the entries under `parentType`'s name.
+*
+* `activeFragments` is the set of fragment names on the current spread path. A document that
+* passed validation cannot contain a fragment cycle, but this parser also runs on trees a
+* caller assembled by hand, and an unbounded walk would hang rather than fail.
+*/
+const collectSelections = (selections, info, tree, parentType, deep, activeFragments) => {
+	const parentTypeName = parentType?.name;
+	if (!parentTypeName) return tree;
+	let fields = tree[parentTypeName];
+	if (!fields) {
+		fields = {};
+		tree[parentTypeName] = fields;
+	}
+	const parentFields = fieldsOf(parentType);
+	for (const selection of selections) {
+		if (isExcluded(info, selection)) continue;
+		if (selection.kind === Kind.FIELD) {
+			const name = selection.name.value;
+			if (isMetaField(name)) continue;
+			const fieldDef = parentFields?.[name];
+			if (!fieldDef) continue;
+			const fieldType = namedTypeOf(fieldDef.type);
+			if (!fieldType) continue;
+			const composite = isCompositeLike(fieldType);
+			const alias = selection.alias?.value || name;
+			let node = fields[alias];
+			if (!node) {
+				node = {
+					name,
+					alias,
+					args: { ...getArgumentValues(fieldDef, selection, info.variableValues) },
+					fieldsByTypeName: composite && fieldType.name ? { [fieldType.name]: {} } : {}
+				};
+				fields[alias] = node;
+			}
+			if (selection.selectionSet && deep && composite) collectSelections(selection.selectionSet.selections, info, node.fieldsByTypeName, fieldType, deep, activeFragments);
+			continue;
+		}
+		if (!deep) continue;
+		if (selection.kind === Kind.FRAGMENT_SPREAD) {
+			const fragmentName = selection.name.value;
+			const fragment = info.fragments?.[fragmentName];
+			if (!fragment) throw new Error(`Drizzle-GraphQL Error: unknown fragment '${fragmentName}' — it is spread in the query but not defined in the document.`);
+			if (activeFragments.has(fragmentName)) continue;
+			const fragmentType = fragment.typeCondition ? typeFromCondition(info, fragment.typeCondition) : parentType;
+			if (!isCompositeLike(fragmentType)) continue;
+			activeFragments.add(fragmentName);
+			try {
+				collectSelections(fragment.selectionSet.selections, info, tree, fragmentType, deep, activeFragments);
+			} finally {
+				activeFragments.delete(fragmentName);
+			}
+			continue;
+		}
+		if (selection.kind === Kind.INLINE_FRAGMENT) {
+			const fragmentType = selection.typeCondition ? typeFromCondition(info, selection.typeCondition) : parentType;
+			if (!isCompositeLike(fragmentType)) continue;
+			collectSelections(selection.selectionSet.selections, info, tree, fragmentType, deep, activeFragments);
+		}
+	}
+	return tree;
+};
+/** The first key of an object, without materializing the whole key array to discard it. */
+const firstKey = (object) => {
+	for (const key in object) return key;
+};
+/**
+* Reads the selection under a resolver's own field out of its `info`, as a tree of
+* {@link ResolveTree} nodes.
+*
+* ```ts
+* const parsed = parseResolveInfo(info, { deep: true })!;
+* const selected = parsed.fieldsByTypeName['Users']; // keyed by response key
+* ```
+*
+* Returns `undefined` when the resolver's field produced no node at all, which in practice
+* means `info` carried no field nodes.
+*/
+const parseResolveInfo = (info, options = {}) => {
+	const fieldNodes = info.fieldNodes;
+	if (!fieldNodes) throw new Error("Drizzle-GraphQL Error: resolve info carries no fieldNodes, so no selection could be read from it.");
+	const tree = collectSelections(fieldNodes, info, {}, info.parentType, options.deep ?? true, /* @__PURE__ */ new Set());
+	const typeKey = firstKey(tree);
+	const fields = typeKey === void 0 ? void 0 : tree[typeKey];
+	const fieldKey = fields && firstKey(fields);
+	return fieldKey === void 0 ? void 0 : fields?.[fieldKey];
+};
+//#endregion
 //#region src/util/builders/aggregates.ts
 /** Operations that aggregate over a set of column values. `count` is handled separately (whole rows). */
 const AGGREGATE_OPS = [
@@ -4768,7 +4979,30 @@ const SEP = "__";
 * arrays (including array-typed number columns), JSON, buffers, and object-shaped columns
 * (e.g. geometry) are excluded entirely.
 */
+/**
+* Cache for {@link classifyAggregateColumns}. Keyed on the table object, then on the name it
+* was classified under — the name only reaches `drizzleColumnToGraphQLType` for enum naming,
+* but a table registered under two names would name its enums differently, so it is part of
+* the key rather than assumed irrelevant.
+*
+* The entries hold this build's GraphQL types and this build's column exclusions, so the
+* cache lives exactly as long as a build: {@link resetAggregateColumnCache} runs at the start
+* of every one, alongside the other per-build registries. Kept across builds it would hand a
+* second build the first build's enum instances, which is a schema with two types of one name.
+*/
+let aggregateColumnSetsCache = /* @__PURE__ */ new WeakMap();
+/** Drops the classifications cached for the previous build. Called once per `generateSchemaData`. */
+const resetAggregateColumnCache = () => {
+	aggregateColumnSetsCache = /* @__PURE__ */ new WeakMap();
+};
 const classifyAggregateColumns = (table, tableName) => {
+	let byName = aggregateColumnSetsCache.get(table);
+	if (!byName) {
+		byName = /* @__PURE__ */ new Map();
+		aggregateColumnSetsCache.set(table, byName);
+	}
+	const cached = byName.get(tableName);
+	if (cached) return cached;
 	const numeric = {};
 	const orderable = {};
 	const all = {};
@@ -4786,11 +5020,13 @@ const classifyAggregateColumns = (table, tableName) => {
 		};
 		if (dataType === "number") numeric[columnName] = column;
 	}
-	return {
+	const sets = {
 		numeric,
 		orderable,
 		all
 	};
+	byName.set(tableName, sets);
+	return sets;
 };
 /**
 * Builds the `${typeName}Aggregate` output type for a table:
@@ -5914,6 +6150,7 @@ const createSchemaBuilder = (adapter) => {
 		registerScalarOverrides(tables, options);
 		registerEnumConfig(options);
 		registerColumnExclusions(tables, options.exclude);
+		resetAggregateColumnCache();
 		const namedRelations = buildNamedRelations(relations ?? {}, tableEntries);
 		for (const excluded of excludedTables) delete namedRelations[excluded];
 		attachTargetPrimaryKeys(namedRelations, tables, (table) => primaryKeyPropNames(table));
@@ -6303,11 +6540,13 @@ const generateDelete = (db, tableName, table, filterArgs, fieldName, single, req
 		}
 	});
 };
+/** The dialect's table config, cached per table — see {@link memoizeTableConfig}. */
+const getTableConfig$5 = memoizeTableConfig(getTableConfig);
 /** Primary-key property names for a MySQL table, including table-level composite keys. */
-const mysqlPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig);
+const mysqlPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig$5);
 const { prepareBuild, addReadFields, finalizeBuild } = createSchemaBuilder({
 	tableClass: MySqlTable,
-	getTableConfig,
+	getTableConfig: getTableConfig$5,
 	primaryKeyPropNames: mysqlPrimaryKeyPropNames,
 	nullOrdering: "nulls-smallest",
 	returnsRows: false,
@@ -7188,12 +7427,14 @@ const createUpdateManyGenerator = (primaryKeyPropNames, runBatch = runUpdateMany
 };
 //#endregion
 //#region src/util/builders/pg.ts
+/** The dialect's table config, cached per table — see {@link memoizeTableConfig}. */
+const getTableConfig$4 = memoizeTableConfig(getTableConfig$1);
 /** Primary-key property names for a PG table, including table-level composite keys. */
-const pgPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig$1);
+const pgPrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig$4);
 const generateUpdateMany$1 = createUpdateManyGenerator(pgPrimaryKeyPropNames);
 const pgSchemaData = createSchemaDataGenerator({
 	tableClass: PgTable,
-	getTableConfig: getTableConfig$1,
+	getTableConfig: getTableConfig$4,
 	primaryKeyPropNames: pgPrimaryKeyPropNames,
 	nullOrdering: "nulls-largest",
 	returnsRows: true,
@@ -7202,8 +7443,10 @@ const pgSchemaData = createSchemaDataGenerator({
 const generateSchemaData$1 = (db, schema, relations, options) => pgSchemaData(db, schema, relations, options);
 //#endregion
 //#region src/util/builders/sqlite.ts
+/** The dialect's table config, cached per table — see {@link memoizeTableConfig}. */
+const getTableConfig$3 = memoizeTableConfig(getTableConfig$2);
 /** Primary-key property names for a SQLite table, including table-level composite keys. */
-const sqlitePrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig$2);
+const sqlitePrimaryKeyPropNames = (table) => getPrimaryKeyPropNamesFromConfig(table, getTableConfig$3);
 /**
 * SQLite's batch runner. A synchronous driver (better-sqlite3) commits the moment its
 * transaction callback returns, so that callback must not be async — an awaited statement
@@ -7248,7 +7491,7 @@ const runSqliteUpdateManyBatch = ({ executor, entries, table, returning, anyNest
 const generateUpdateMany = createUpdateManyGenerator(sqlitePrimaryKeyPropNames, runSqliteUpdateManyBatch);
 const sqliteSchemaData = createSchemaDataGenerator({
 	tableClass: SQLiteTable,
-	getTableConfig: getTableConfig$2,
+	getTableConfig: getTableConfig$3,
 	primaryKeyPropNames: sqlitePrimaryKeyPropNames,
 	nullOrdering: "nulls-smallest",
 	returnsRows: true,
@@ -7262,11 +7505,14 @@ const generateSchemaData = (db, schema, relations, options) => sqliteSchemaData(
 //#endregion
 //#region src/util/selection.ts
 const contextCache = /* @__PURE__ */ new WeakMap();
+const getMySqlTableConfig = memoizeTableConfig(getTableConfig);
+const getPgTableConfig = memoizeTableConfig(getTableConfig$1);
+const getSQLiteTableConfig = memoizeTableConfig(getTableConfig$2);
 /** The dialect's `getTableConfig`, which is the only place a composite primary key shows up. */
 const tableConfigFor = (db) => {
-	if (is(db, MySqlAsyncDatabase)) return getTableConfig;
-	if (is(db, PgAsyncDatabase)) return getTableConfig$1;
-	if (is(db, SQLiteAsyncDatabase)) return getTableConfig$2;
+	if (is(db, MySqlAsyncDatabase)) return getMySqlTableConfig;
+	if (is(db, PgAsyncDatabase)) return getPgTableConfig;
+	if (is(db, SQLiteAsyncDatabase)) return getSQLiteTableConfig;
 	throw new Error("Drizzle-GraphQL Error: unsupported database instance — expected a PostgreSQL, MySQL or SQLite one.");
 };
 const contextFor = (db) => {
@@ -7347,7 +7593,11 @@ const selectionToWith = (info, options) => {
 	if (!tables[table]) throw new Error(`Drizzle-GraphQL Error: '${table}' is not a table in the Drizzle schema.`);
 	if (!relationMap[table]) return;
 	const parsed = parseInfo(info);
-	const params = extractRelationsParams(relationMap, tables, table, parsed, resolveObjectTypeName(table, typeNameMapper, resolveName), typeNameMapper, filterCtx, void 0, void 0, void 0, resolveName);
+	const params = extractRelationsParams(relationMap, tables, table, parsed, resolveObjectTypeName(table, typeNameMapper, resolveName), {
+		typeNameMapper,
+		filterCtx,
+		resolveName
+	});
 	return params && Object.keys(params).length ? params : void 0;
 };
 /**
@@ -7428,6 +7678,6 @@ const buildSchema = (db, config) => {
 	};
 };
 //#endregion
-export { GraphQLBigIntString, GraphQLDate, GraphQLDateTime, GraphQLDecimalString, GraphQLJSON, GraphQLUUID, buildSchema, createRelationResolverFactory, defaultErrorMapper, drizzleError, drizzleExecutorKey, drizzleExtension, extractFilters, extractOrderBy, extractRelationJoinColumns, identifyRows, isDrizzleFieldExtension, resolveSelection, selectionToWith, singularizeMapper };
+export { GraphQLBigIntString, GraphQLDate, GraphQLDateTime, GraphQLDecimalString, GraphQLJSON, GraphQLUUID, buildSchema, createRelationResolverFactory, defaultErrorMapper, drizzleError, drizzleExecutorKey, drizzleExtension, extractFilters, extractOrderBy, extractRelationJoinColumns, identifyRows, isDrizzleFieldExtension, parseResolveInfo, resolveSelection, selectionToWith, singularizeMapper };
 
 //# sourceMappingURL=index.js.map