@m1212e/rumble 0.22.2 → 0.23.2

package/out/index.mjs

@@ -1,6 +1,6 @@
 import { t as lazy } from "./lazy-C7IyM4M4.mjs";
 import { t as generateFromSchema } from "./generate-0QFVc3Sg.mjs";
-import { GraphQLError } from "graphql";
+import { GraphQLError, GraphQLSchema } from "graphql";
 import { EnvelopArmorPlugin } from "@escape.tech/graphql-armor";
 import { useDisableIntrospection } from "@graphql-yoga/plugin-disable-introspection";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
@@ -10,14 +10,14 @@ import { createPubSub, createYoga } from "graphql-yoga";
 import { One, count, getTableColumns, getTableName, is, isTable, relationsFilterToSQL, sql } from "drizzle-orm";
 import { toCamelCase } from "drizzle-orm/casing";
 import { PgColumn, PgEnumColumn, PgEnumObjectColumn, PgTable, isPgEnum } from "drizzle-orm/pg-core";
+import { MySqlEnumColumn, MySqlEnumObjectColumn, MySqlTable } from "drizzle-orm/mysql-core";
 import pluralize from "pluralize";
-import { MySqlTable } from "drizzle-orm/mysql-core";
 import { SQLiteTable } from "drizzle-orm/sqlite-core";
 import SchemaBuilder, { BasePlugin } from "@pothos/core";
 import DrizzlePlugin from "@pothos/plugin-drizzle";
 import SmartSubscriptionsPlugin, { subscribeOptionsFromIterator } from "@pothos/plugin-smart-subscriptions";
-import TracingPlugin, { isRootField } from "@pothos/plugin-tracing";
-import { DateResolver, DateTimeISOResolver, JSONResolver } from "graphql-scalars";
+import TracingPlugin, { isRootField, wrapResolver } from "@pothos/plugin-tracing";
+import { BigIntResolver, ByteResolver, DateResolver, DateTimeISOResolver, JSONResolver } from "graphql-scalars";
 //#region lib/types/rumbleError.ts
 /**
 * An error that gets raised by rumble whenever something does not go according to plan.
@@ -180,7 +180,7 @@ function mapNullFieldsToUndefined(obj) {
 }
 //#endregion
 //#region package.json
-var version = "0.22.2";
+var version = "0.23.2";
 //#endregion
 //#region lib/helpers/mergeFilters.ts
 function mergeFilters(filterA, filterB, mode = "AND") {
@@ -199,23 +199,47 @@ function mergeFilters(filterA, filterB, mode = "AND") {
 }
 //#endregion
 //#region lib/helpers/sqlTypes/types.ts
+/**
+* Strips parameter suffixes like `(256)`, `(10,2)` and timezone modifiers
+* (`with time zone`, `without time zone`) from raw getSQLType() output so
+* every classifier works on the base type name only.
+*/
+function normalizeSQLType(raw) {
+	return raw.replace(/\s*with(?:out)?\s+time\s+zone/i, "").replace(/\s*\([^)]*\)/, "").trim().toLowerCase();
+}
 const intLikeSQLTypeStrings = [
 	"serial",
 	"int",
 	"integer",
 	"tinyint",
 	"smallint",
-	"mediumint"
+	"mediumint",
+	"int2",
+	"int4",
+	"smallserial"
 ];
 function isIntLikeSQLTypeString(sqlType) {
 	return intLikeSQLTypeStrings.includes(sqlType);
 }
+const bigIntLikeSQLTypeStrings = [
+	"bigint",
+	"bigserial",
+	"int8",
+	"bigint unsigned"
+];
+function isBigIntLikeSQLTypeString(sqlType) {
+	return bigIntLikeSQLTypeStrings.includes(sqlType);
+}
 const floatLikeSQLTypeStrings = [
 	"real",
 	"decimal",
 	"double",
 	"float",
-	"numeric"
+	"numeric",
+	"double precision",
+	"float4",
+	"float8",
+	"money"
 ];
 function isFloatLikeSQLTypeString(sqlType) {
 	return floatLikeSQLTypeStrings.includes(sqlType);
@@ -225,7 +249,20 @@ const stringLikeSQLTypeStrings = [
 	"text",
 	"varchar",
 	"char",
-	"text(256)"
+	"character varying",
+	"character",
+	"inet",
+	"cidr",
+	"macaddr",
+	"macaddr8",
+	"interval",
+	"time",
+	"year",
+	"binary",
+	"varbinary",
+	"tinytext",
+	"mediumtext",
+	"longtext"
 ];
 function isStringLikeSQLTypeString(sqlType) {
 	return stringLikeSQLTypeStrings.includes(sqlType);
@@ -234,7 +271,7 @@ const IDLikeSQLTypeStrings = ["uuid"];
 function isIDLikeSQLTypeString(sqlType) {
 	return IDLikeSQLTypeStrings.includes(sqlType);
 }
-const booleanSQLTypeStrings = ["boolean"];
+const booleanSQLTypeStrings = ["boolean", "bool"];
 function isBooleanSQLTypeString(sqlType) {
 	return booleanSQLTypeStrings.includes(sqlType);
 }
@@ -250,16 +287,23 @@ const jsonLikeSQLTypeStrings = ["json", "jsonb"];
 function isJSONLikeSQLTypeString(sqlType) {
 	return jsonLikeSQLTypeStrings.includes(sqlType);
 }
-[
-	...intLikeSQLTypeStrings,
-	...floatLikeSQLTypeStrings,
-	...stringLikeSQLTypeStrings,
-	...IDLikeSQLTypeStrings,
-	...booleanSQLTypeStrings,
-	...dateTimeLikeSQLTypeStrings,
-	...dateLikeSQLTypeStrings,
-	...jsonLikeSQLTypeStrings
+const jsonFallbackSQLTypeStrings = [
+	"point",
+	"line",
+	"lseg",
+	"box",
+	"path",
+	"polygon",
+	"circle",
+	"geometry"
 ];
+function isJSONFallbackSQLTypeString(sqlType) {
+	return jsonFallbackSQLTypeStrings.includes(sqlType) || sqlType.startsWith("geometry");
+}
+const bytesSQLTypeStrings = ["bytea", "blob"];
+function isBytesSQLTypeString(sqlType) {
+	return bytesSQLTypeStrings.includes(sqlType);
+}
 const UnknownTypeRumbleError = (sqlType, additionalInfo) => new RumbleError(`RumbleError: Unknown SQL type '${sqlType}'. Please open an issue (https://github.com/m1212e/rumble/issues) so it can be added. (${additionalInfo})`);
 //#endregion
 //#region lib/helpers/sqlTypes/distinctValuesFromSQLType.ts
@@ -374,16 +418,17 @@ function isDynamicQueryFilter(filter) {
 function isStaticQueryFilter(filter) {
 	return typeof filter !== "function";
 }
-const nothingRegisteredWarningLogger = debounce((model, action) => {
-	console.warn(`
-Warning! No abilities have been registered for
-
-    ${model}/${action}
-
-but has been accessed. This will block everything. If this is intended, you can ignore this warning. If not, please ensure that you register the ability in your ability builder.
-`);
+const makeNothingRegisteredWarner = (logger) => debounce((model, action) => {
+	const msg = `No abilities registered for ${model}/${action} — blocking everything. Register the ability or ignore this warning if intentional.`;
+	if (logger) logger.warn({
+		"rumble.table": model,
+		"rumble.action": action
+	}, msg);
+	else console.warn(msg);
 }, 1e3);
-const createAbilityBuilder = ({ db, actions, defaultLimit, otel }) => {
+const createAbilityBuilder = ({ db, actions, defaultLimit, otel, logger: loggerConfig }) => {
+	const log = loggerConfig?.enabled ? loggerConfig.logger : void 0;
+	const nothingRegisteredWarningLogger = makeNothingRegisteredWarner(log);
 	let hasBeenBuilt = false;
 	const createBuilderForTable = () => {
 		const queryFilters = /* @__PURE__ */ new Map();
@@ -631,7 +676,8 @@ by: (explicitFilter) => {
 						* Merges the current query filters with the provided filters for this call only
 						*/
 						function merge(p) {
-							return internalTransformer(mergeFilters(ret.query.many, p), p.limit);
+							const merged = mergeFilters(ret.query.many, p);
+							return internalTransformer(merged, p.limit);
 						}
 						ret.merge = merge;
 						return ret;
@@ -673,14 +719,39 @@ by: (explicitFilter) => {
 								span?.setAttribute("abilities.status", "applied");
 								return transformToResponse(mergedFilters);
 							};
-							if (otel?.enabled && otel.tracer) return otel.tracer.startActiveSpan(`prepare_query_abilities_${action}`, (span) => {
+							if (otel?.enabled && otel.tracer) return otel.tracer.startActiveSpan(`rumble.abilities.prepare`, (span) => {
+								span.setAttribute("rumble.action", action);
+								span.setAttribute("rumble.table", tableName.toString());
 								try {
-									return assembleAbilities(span);
+									const attrs = {
+										"rumble.table": tableName.toString(),
+										"rumble.action": action
+									};
+									const proxy = new Proxy(span, { get(target, prop) {
+										if (prop === "setAttribute") return (k, v) => {
+											attrs[k] = v;
+											return target.setAttribute(k, v);
+										};
+										return target[prop];
+									} });
+									const result = assembleAbilities(proxy);
+									log?.debug(attrs, "abilities prepared");
+									return result;
 								} finally {
 									span.end();
 								}
 							});
-							else return assembleAbilities();
+							else {
+								const attrs = {
+									"rumble.table": tableName.toString(),
+									"rumble.action": action
+								};
+								const result = assembleAbilities(log ? { setAttribute: (k, v) => {
+									attrs[k] = v;
+								} } : void 0);
+								log?.debug(attrs, "abilities prepared");
+								return result;
+							}
 						} };
 					} };
 				};
@@ -709,29 +780,14 @@ const createOrderArgImplementer = ({ db, schemaBuilder }) => {
 		if (ret) return ret;
 		const implement = () => {
 			return schemaBuilder.inputType(inputTypeName, { fields: (t) => {
-				const fields = Object.entries(tableSchema.columns).reduce((acc, [key]) => {
+				return Object.entries(tableSchema.columns).reduce((acc, [key]) => {
+					if (key.startsWith("__")) return acc;
 					acc[key] = t.field({
 						type: sortingParameterEnumRef(),
 						required: false
 					});
 					return acc;
 				}, {});
-				const relations = Object.entries(tableSchema.relations ?? {}).reduce((acc, [key, value]) => {
-					const targetTsName = value.targetTableName;
-					const referenceModel = orderArgImplementer({ dbName: tableHelper({
-						db,
-						table: targetTsName
-					}).dbName });
-					acc[key] = t.field({
-						type: referenceModel,
-						required: false
-					});
-					return acc;
-				}, {});
-				return {
-					...fields,
-					...relations
-				};
 			} });
 		};
 		ret = implement();
@@ -743,10 +799,10 @@ const createOrderArgImplementer = ({ db, schemaBuilder }) => {
 //#endregion
 //#region lib/enum.ts
 /**
-* Checks if a column is a Postgres enum column
+* Checks if a column is a database enum column (Postgres or MySQL).
 */
 function isEnumSchema(schemaType) {
-	return is(schemaType, PgEnumColumn) || is(schemaType, PgEnumObjectColumn);
+	return is(schemaType, PgEnumColumn) || is(schemaType, PgEnumObjectColumn) || is(schemaType, MySqlEnumColumn) || is(schemaType, MySqlEnumObjectColumn);
 }
 const createEnumImplementer = ({ schema, schemaBuilder }) => {
 	const referenceStorage = /* @__PURE__ */ new Map();
@@ -778,7 +834,12 @@ const createEnumImplementer = ({ schema, schemaBuilder }) => {
 		if (enumObject) {
 			enumSchemaName = enumObject.enumName;
 			enumValues = enumObject.enumValues;
-		} else if (enumColumn) {
+		} else if (enumColumn) if (is(enumColumn, MySqlEnumColumn) || is(enumColumn, MySqlEnumObjectColumn)) {
+			enumValues = enumColumn.enumValues;
+			const colTable = enumColumn.table;
+			const tableName = colTable && isTable(colTable) ? getTableName(colTable) : void 0;
+			enumSchemaName = tableName ? `${tableName}_${enumColumn.name}` : enumColumn.name;
+		} else {
 			const pgEnum = enumColumn.enum;
 			if (!pgEnum) throw new RumbleError(`Could not find enum definition on column. Make sure the column is a pgEnum column.`);
 			enumSchemaName = pgEnum.enumName;
@@ -797,16 +858,21 @@ const createEnumImplementer = ({ schema, schemaBuilder }) => {
 //#endregion
 //#region lib/helpers/sqlTypes/mapSQLTypeToTSType.ts
 function mapSQLTypeToGraphQLType({ sqlType, fieldName }) {
+	if (/^enum\(/.test(sqlType)) return "String";
+	const normalized = normalizeSQLType(sqlType);
 	let ret;
-	if (isIntLikeSQLTypeString(sqlType)) ret = "Int";
-	if (isFloatLikeSQLTypeString(sqlType)) ret = "Float";
-	if (isStringLikeSQLTypeString(sqlType)) if (fieldName && (fieldName.toLowerCase().endsWith("_id") || fieldName.toLowerCase().endsWith("id"))) ret = "ID";
+	if (isIntLikeSQLTypeString(normalized)) ret = "Int";
+	if (isBigIntLikeSQLTypeString(normalized)) ret = "BigInt";
+	if (isFloatLikeSQLTypeString(normalized)) ret = "Float";
+	if (isStringLikeSQLTypeString(normalized)) if (fieldName && (fieldName.toLowerCase().endsWith("_id") || fieldName.toLowerCase().endsWith("id"))) ret = "ID";
 	else ret = "String";
-	if (isIDLikeSQLTypeString(sqlType)) ret = "ID";
-	if (isBooleanSQLTypeString(sqlType)) ret = "Boolean";
-	if (isDateTimeLikeSQLTypeString(sqlType)) ret = "DateTime";
-	if (isDateLikeSQLTypeString(sqlType)) ret = "Date";
-	if (isJSONLikeSQLTypeString(sqlType)) ret = "JSON";
+	if (isIDLikeSQLTypeString(normalized)) ret = "ID";
+	if (isBooleanSQLTypeString(normalized)) ret = "Boolean";
+	if (isDateTimeLikeSQLTypeString(normalized)) ret = "DateTime";
+	if (isDateLikeSQLTypeString(normalized)) ret = "Date";
+	if (isJSONLikeSQLTypeString(normalized)) ret = "JSON";
+	if (isJSONFallbackSQLTypeString(normalized)) ret = "JSON";
+	if (isBytesSQLTypeString(normalized)) ret = "Bytes";
 	if (ret !== void 0) return ret;
 	throw UnknownTypeRumbleError(sqlType, "SQL to GQL");
 }
@@ -816,6 +882,60 @@ const makeDefaultName = (dbName) => `${capitalize(toCamelCase(dbName.toString())
 const createWhereArgImplementer = ({ db, schemaBuilder, enumImplementer }) => {
 	const referenceStorage = /* @__PURE__ */ new Map();
 	const enumArrayWhereInputStorage = /* @__PURE__ */ new Map();
+	const scalarArrayWhereInputStorage = /* @__PURE__ */ new Map();
+	const scalarArrayWhereInputName = (gqlType) => `${gqlType}ArrayWhereInputArgument`;
+	const getScalarArrayWhereInput = (gqlType) => {
+		const typeName = scalarArrayWhereInputName(gqlType);
+		const existing = scalarArrayWhereInputStorage.get(typeName);
+		if (existing) return existing;
+		const ret = schemaBuilder.inputRef(typeName);
+		scalarArrayWhereInputStorage.set(typeName, ret);
+		ret.implement({ fields: (t) => ({
+			eq: t.field({
+				type: [gqlType],
+				required: false
+			}),
+			ne: t.field({
+				type: [gqlType],
+				required: false
+			}),
+			in: t.field({
+				type: [[gqlType]],
+				required: false
+			}),
+			notIn: t.field({
+				type: [[gqlType]],
+				required: false
+			}),
+			isNull: t.boolean({ required: false }),
+			isNotNull: t.boolean({ required: false }),
+			arrayOverlaps: t.field({
+				type: [gqlType],
+				required: false
+			}),
+			arrayContained: t.field({
+				type: [gqlType],
+				required: false
+			}),
+			arrayContains: t.field({
+				type: [gqlType],
+				required: false
+			}),
+			AND: t.field({
+				type: [ret],
+				required: false
+			}),
+			OR: t.field({
+				type: [ret],
+				required: false
+			}),
+			NOT: t.field({
+				type: ret,
+				required: false
+			})
+		}) });
+		return ret;
+	};
 	const getEnumArrayWhereInput = (enumImpl) => {
 		const typeName = `${enumImpl.name}WhereInputArgument`;
 		const existing = enumArrayWhereInputStorage.get(typeName);
@@ -879,39 +999,82 @@ const createWhereArgImplementer = ({ db, schemaBuilder, enumImplementer }) => {
 		const ret = schemaBuilder.inputRef(inputTypeName);
 		referenceStorage.set(inputTypeName, ret);
 		ret.implement({ fields: (t) => {
-			const mapSQLTypeStringToInputPothosType = (sqlType, fieldName) => {
+			const mapSQLTypeStringToInputPothosType = (sqlType, fieldName, isArray) => {
 				const gqlType = mapSQLTypeToGraphQLType({
 					sqlType,
 					fieldName
 				});
+				if (isArray) return t.field({
+					type: getScalarArrayWhereInput(gqlType),
+					required: false
+				});
 				switch (gqlType) {
-					case "Int": return t.field({ type: "IntWhereInputArgument" });
-					case "String": return t.field({ type: "StringWhereInputArgument" });
-					case "Boolean": return t.field({ type: "BooleanWhereInputArgument" });
-					case "Date": return t.field({ type: "DateWhereInputArgument" });
-					case "DateTime": return t.field({ type: "DateWhereInputArgument" });
-					case "Float": return t.field({ type: "FloatWhereInputArgument" });
-					case "ID": return t.field({ type: "IDWhereInputArgument" });
-					case "JSON": return t.field({ type: "JSONWhereInputArgument" });
+					case "Int": return t.field({
+						type: "IntWhereInputArgument",
+						required: false
+					});
+					case "BigInt": return t.field({
+						type: "BigIntWhereInputArgument",
+						required: false
+					});
+					case "String": return t.field({
+						type: "StringWhereInputArgument",
+						required: false
+					});
+					case "Boolean": return t.field({
+						type: "BooleanWhereInputArgument",
+						required: false
+					});
+					case "Date": return t.field({
+						type: "DateWhereInputArgument",
+						required: false
+					});
+					case "DateTime": return t.field({
+						type: "DateTimeWhereInputArgument",
+						required: false
+					});
+					case "Float": return t.field({
+						type: "FloatWhereInputArgument",
+						required: false
+					});
+					case "ID": return t.field({
+						type: "IDWhereInputArgument",
+						required: false
+					});
+					case "JSON": return t.field({
+						type: "JSONWhereInputArgument",
+						required: false
+					});
+					case "Bytes": return null;
 					default: throw new RumbleError(`Unsupported argument type ${gqlType} for column ${sqlType}`);
 				}
 			};
 			const fields = Object.entries(tableSchema.columns).reduce((acc, [key, value]) => {
+				if (key.startsWith("__")) return acc;
+				let isArray = false;
+				if (is(value, PgColumn)) {
+					const dims = value.dimensions;
+					if (dims && dims > 0) isArray = true;
+				}
 				if (isEnumSchema(value)) {
 					const enumImpl = enumImplementer({ enumColumn: value });
 					acc[key] = t.field({
-						type: value.dimensions > 0 ? getEnumArrayWhereInput(enumImpl) : enumImpl,
+						type: isArray ? getEnumArrayWhereInput(enumImpl) : enumImpl,
 						required: false
 					});
-				} else acc[key] = mapSQLTypeStringToInputPothosType(value.getSQLType(), key);
+				} else {
+					const field = mapSQLTypeStringToInputPothosType(value.getSQLType(), key, isArray);
+					if (field !== null) acc[key] = field;
+				}
 				return acc;
 			}, {});
 			const relations = Object.entries(tableSchema.relations ?? {}).reduce((acc, [key, value]) => {
 				const targetTsName = value.targetTableName;
-				const referenceModel = whereArgImplementer({ dbName: tableHelper({
+				const relationSchema = tableHelper({
 					db,
 					table: targetTsName
-				}).dbName });
+				});
+				const referenceModel = whereArgImplementer({ dbName: relationSchema.dbName });
 				acc[key] = t.field({
 					type: referenceModel,
 					required: false
@@ -1117,6 +1280,11 @@ function buildPothosResponseTypeFromGraphQLType({ builder, sqlType, fieldName, n
 	});
 	switch (gqlType) {
 		case "Int": return isArray ? builder.exposeIntList(fieldName, { nullable }) : builder.exposeInt(fieldName, { nullable });
+		case "BigInt": return builder.field({
+			type: isArray ? ["BigInt"] : "BigInt",
+			resolve: (element) => element[fieldName],
+			nullable
+		});
 		case "String": return isArray ? builder.exposeStringList(fieldName, { nullable }) : builder.exposeString(fieldName, { nullable });
 		case "Boolean": return isArray ? builder.exposeBooleanList(fieldName, { nullable }) : builder.exposeBoolean(fieldName, { nullable });
 		case "Date": return builder.field({
@@ -1126,7 +1294,11 @@ function buildPothosResponseTypeFromGraphQLType({ builder, sqlType, fieldName, n
 		});
 		case "DateTime": return builder.field({
 			type: isArray ? ["DateTime"] : "DateTime",
-			resolve: (element) => element[fieldName],
+			resolve: (element) => {
+				const v = element[fieldName];
+				if (v == null) return v;
+				return v instanceof Date ? v : new Date(v);
+			},
 			nullable
 		});
 		case "Float": return isArray ? builder.exposeFloatList(fieldName, { nullable }) : builder.exposeFloat(fieldName, { nullable });
@@ -1136,6 +1308,15 @@ function buildPothosResponseTypeFromGraphQLType({ builder, sqlType, fieldName, n
 			resolve: (element) => element[fieldName],
 			nullable
 		});
+		case "Bytes": return builder.field({
+			type: "Bytes",
+			resolve: (element) => {
+				const v = element[fieldName];
+				if (v == null) return v;
+				return Buffer.isBuffer(v) ? v.toString("base64") : String(v);
+			},
+			nullable
+		});
 		default: throw new RumbleError(`Unsupported object type ${gqlType} for column ${fieldName}`);
 	}
 }
@@ -1167,14 +1348,17 @@ function isPostgresDB(db) {
 //#endregion
 //#region lib/search.ts
 async function initSearchIfApplicable(input) {
+	const log = input.logger?.enabled ? input.logger.logger : void 0;
 	if (!isPostgresDB(input.db)) {
-		console.info("Database dialect is not compatible with search, skipping search initialization. Only PostgreSQL is supported.");
+		const msg = "Database dialect is not compatible with search, skipping search initialization. Only PostgreSQL is supported.";
+		log ? log.info({}, msg) : console.info(msg);
 		return;
 	}
 	try {
 		await input.db.execute(sql`CREATE EXTENSION IF NOT EXISTS pg_trgm;`);
 	} catch (error) {
-		console.error("Failed to create pg_trgm extension. Search functionality may not work. Ensure the database user has CREATE privilege or the extension is pre-installed.", error);
+		const msg = "Failed to create pg_trgm extension. Search functionality may not work. Ensure the database user has CREATE privilege or the extension is pre-installed.";
+		log ? log.error({ err: error }, msg) : console.error(msg, error);
 		return;
 	}
 	if (input.search?.threshold) {
@@ -1233,13 +1417,17 @@ const isProbablyAConfigObject = (t) => {
 	].find((e) => e === k))) return true;
 	return false;
 };
-const createObjectImplementer = ({ db, search, schemaBuilder, makePubSubInstance, whereArgImplementer, orderArgImplementer, enumImplementer, abilityBuilder }) => {
+const createObjectImplementer = ({ db, search, logger: loggerConfig, schemaBuilder, makePubSubInstance, whereArgImplementer, orderArgImplementer, enumImplementer, abilityBuilder }) => {
 	return ({ table, refName, readAction = "read", adjust }) => {
 		const tableSchema = tableHelper({
 			db,
 			table
 		});
-		if (Object.keys(tableSchema.primaryKey).length === 0) console.warn(`Could not find primary key for ${table.toString()}. Cannot register subscriptions!`);
+		if (Object.keys(tableSchema.primaryKey).length === 0) {
+			const log = loggerConfig?.enabled ? loggerConfig.logger : void 0;
+			const msg = `Could not find primary key for ${table.toString()}. Cannot register subscriptions!`;
+			log ? log.warn({ "rumble.table": table.toString() }, msg) : console.warn(msg);
+		}
 		const primaryKey = Object.values(tableSchema.primaryKey)[0];
 		const { registerOnInstance } = makePubSubInstance({ table });
 		return schemaBuilder.drizzleObject(table, {
@@ -1248,7 +1436,9 @@ const createObjectImplementer = ({ db, search, schemaBuilder, makePubSubInstance
 				if (!primaryKey) return;
 				const primaryKeyValue = element[primaryKey.name];
 				if (!primaryKeyValue) {
-					console.warn(`Could not find primary key value for ${JSON.stringify(element)}. Cannot register subscription!`);
+					const log = loggerConfig?.enabled ? loggerConfig.logger : void 0;
+					const msg = `Could not find primary key value for element on ${table.toString()}. Cannot register subscription!`;
+					log ? log.warn({ "rumble.table": table.toString() }, msg) : console.warn(msg);
 					return;
 				}
 				registerOnInstance({
@@ -1279,6 +1469,10 @@ const createObjectImplementer = ({ db, search, schemaBuilder, makePubSubInstance
 					};
 				} })) ?? {};
 				const fields = Object.entries(columns).reduce((acc, [key, column]) => {
+					if (key.startsWith("__")) {
+						console.warn(`Skipping column "${key}" on table "${tableSchema.tsName}": names starting with "__" are reserved by GraphQL introspection. Use a custom adjust() call if you really need to expose this column.`);
+						return acc;
+					}
 					if (userAdjustments[key]) {
 						const { params, creatorFunction, configObject } = configMap.get(userAdjustments[key]);
 						if (typeof configObject.nullable !== "boolean") configObject.nullable = !column.notNull;
@@ -1479,7 +1673,8 @@ const createPubSubInstance = ({ subscriptions }) => {
 };
 //#endregion
 //#region lib/query.ts
-const createQueryImplementer = ({ db, schemaBuilder, search, whereArgImplementer, orderArgImplementer, makePubSubInstance }) => {
+const createQueryImplementer = ({ db, schemaBuilder, search, logger: loggerConfig, whereArgImplementer, orderArgImplementer, makePubSubInstance }) => {
+	const registeredQueryFieldNames = /* @__PURE__ */ new Set();
 	return ({ table, readAction = "read", listAction = "read" }) => {
 		const WhereArg = whereArgImplementer({ table });
 		const OrderArg = orderArgImplementer({ table });
@@ -1489,6 +1684,12 @@ const createQueryImplementer = ({ db, schemaBuilder, search, whereArgImplementer
 		});
 		const primaryKeyField = Object.values(tableSchema.primaryKey)[0];
 		const { registerOnInstance } = makePubSubInstance({ table });
+		const pluralName = pluralize.plural(table.toString());
+		const singularName = pluralize.singular(table.toString());
+		for (const name of [pluralName, singularName]) {
+			if (registeredQueryFieldNames.has(name)) throw new RumbleError(`Duplicate query field "${name}": the table "${table.toString()}" generates a query field that collides with one already registered. Use unique table names (or refNames) to avoid plural/singular collisions (e.g. "post" and "posts").`);
+			registeredQueryFieldNames.add(name);
+		}
 		return schemaBuilder.queryFields((t) => {
 			const manyArgs = {
 				where: t.arg({
@@ -1505,11 +1706,11 @@ const createQueryImplementer = ({ db, schemaBuilder, search, whereArgImplementer
 			};
 			if (!search?.enabled) delete manyArgs.search;
 			return {
-				[pluralize.plural(table.toString())]: t.drizzleField({
+				[pluralName]: t.drizzleField({
 					type: [table],
 					nullable: false,
 					smartSubscription: true,
-					description: `List all ${pluralize.plural(table.toString())}`,
+					description: `List all ${pluralName}`,
 					subscribe: (subscriptions, _root, _args, _ctx, _info) => {
 						registerOnInstance({
 							instance: subscriptions,
@@ -1537,17 +1738,21 @@ const createQueryImplementer = ({ db, schemaBuilder, search, whereArgImplementer
 						if (filter.columns) queryInstance.columns = filter.columns;
 						if (search?.enabled && args.search && args.search.length > 0 && search?.cpu_operator_cost) return db.transaction(async (tx) => {
 							if (isPostgresDB(tx)) await tx.execute(sql.raw(`SET cpu_operator_cost = ${search.cpu_operator_cost};`));
-							else console.info("Database dialect is not postgresql, cannot set cpu_operator_cost.");
+							else {
+								const msg = "Database dialect is not postgresql, cannot set cpu_operator_cost.";
+								const log = loggerConfig?.enabled ? loggerConfig.logger : void 0;
+								log ? log.info({}, msg) : console.info(msg);
+							}
 							return tx.query[table].findMany(queryInstance);
 						});
 						return db.query[table].findMany(queryInstance);
 					}
 				}),
-				[pluralize.singular(table.toString())]: t.drizzleField({
+				[singularName]: t.drizzleField({
 					type: table,
 					nullable: false,
 					smartSubscription: true,
-					description: `Get a single ${pluralize.singular(table.toString())} by ID`,
+					description: `Get a single ${singularName} by ID`,
 					args: { id: t.arg.id({ required: true }) },
 					resolve: (query, _root, args, ctx, _info) => {
 						deepSetProto(args);
@@ -1723,6 +1928,96 @@ function implementDefaultWhereInputArgs(schemaBuilder) {
 		OR: t.field({ type: [JSONWhereInputArgument] }),
 		NOT: t.field({ type: JSONWhereInputArgument })
 	}) });
+	const BigIntWhereInputArgument = schemaBuilder.inputRef("BigIntWhereInputArgument").implement({ fields: (t) => ({
+		eq: t.field({
+			type: "BigInt",
+			required: false
+		}),
+		ne: t.field({
+			type: "BigInt",
+			required: false
+		}),
+		gt: t.field({
+			type: "BigInt",
+			required: false
+		}),
+		gte: t.field({
+			type: "BigInt",
+			required: false
+		}),
+		lt: t.field({
+			type: "BigInt",
+			required: false
+		}),
+		lte: t.field({
+			type: "BigInt",
+			required: false
+		}),
+		in: t.field({
+			type: ["BigInt"],
+			required: false
+		}),
+		notIn: t.field({
+			type: ["BigInt"],
+			required: false
+		}),
+		isNull: t.boolean(),
+		isNotNull: t.boolean(),
+		AND: t.field({ type: [BigIntWhereInputArgument] }),
+		OR: t.field({ type: [BigIntWhereInputArgument] }),
+		NOT: t.field({ type: BigIntWhereInputArgument })
+	}) });
+	const DateTimeWhereInputArgument = schemaBuilder.inputRef("DateTimeWhereInputArgument").implement({ fields: (t) => ({
+		eq: t.field({
+			type: "DateTime",
+			required: false
+		}),
+		ne: t.field({
+			type: "DateTime",
+			required: false
+		}),
+		gt: t.field({
+			type: "DateTime",
+			required: false
+		}),
+		gte: t.field({
+			type: "DateTime",
+			required: false
+		}),
+		lt: t.field({
+			type: "DateTime",
+			required: false
+		}),
+		lte: t.field({
+			type: "DateTime",
+			required: false
+		}),
+		in: t.field({
+			type: ["DateTime"],
+			required: false
+		}),
+		notIn: t.field({
+			type: ["DateTime"],
+			required: false
+		}),
+		isNull: t.boolean(),
+		isNotNull: t.boolean(),
+		arrayOverlaps: t.field({
+			type: ["DateTime"],
+			required: false
+		}),
+		arrayContained: t.field({
+			type: ["DateTime"],
+			required: false
+		}),
+		arrayContains: t.field({
+			type: ["DateTime"],
+			required: false
+		}),
+		AND: t.field({ type: [DateTimeWhereInputArgument] }),
+		OR: t.field({ type: [DateTimeWhereInputArgument] }),
+		NOT: t.field({ type: DateTimeWhereInputArgument })
+	}) });
 }
 //#endregion
 //#region lib/runtimeFiltersPlugin/filterTypes.ts
@@ -1733,9 +2028,11 @@ const applyFiltersKey = "applyFilters";
 var RuntimeFiltersPlugin = class extends BasePlugin {
 	tracer;
 	tracerEnabled;
+	logger;
 	onTypeConfig(typeConfig) {
 		this.tracer = this.builder.options.otel?.tracer;
 		this.tracerEnabled = this.builder.options.otel?.enabled;
+		this.logger = this.builder.options.logger?.enabled ? this.builder.options.logger.logger : void 0;
 		return typeConfig;
 	}
 	wrapResolve(resolver, fieldConfig) {
@@ -1764,7 +2061,8 @@ var RuntimeFiltersPlugin = class extends BasePlugin {
 				}));
 				let resolved, prefetchedFilters;
 				if (this.tracer && this.tracerEnabled) {
-					const o = await this.tracer.startActiveSpan(`apply_filters`, async (span) => {
+					const o = await this.tracer.startActiveSpan(`rumble.filter.resolve`, async (span) => {
+						span.setAttribute("graphql.field.name", fieldConfig.name);
 						try {
 							return await Promise.all([resolver(parent, args, context, info), prefetchedFiltersPromises]);
 						} finally {
@@ -1786,17 +2084,37 @@ var RuntimeFiltersPlugin = class extends BasePlugin {
 					return acc;
 				}, /* @__PURE__ */ new Set()));
 				span?.setAttribute("filters.allowed", allowed.length);
+				this.logger?.debug({
+					"graphql.field.name": fieldConfig.name,
+					"filters.total": allFilters.length,
+					"filters.allowed": allowed.length
+				}, "runtime filters applied");
 				if (Array.isArray(resolved)) return allowed;
 				return allowed[0] ?? null;
 			};
-			if (this.tracer && this.tracerEnabled) return this.tracer.startActiveSpan(`filter_${fieldConfig.name}`, async (span) => {
+			if (this.tracer && this.tracerEnabled) return this.tracer.startActiveSpan(`rumble.filter.apply`, async (span) => {
+				span.setAttribute("graphql.field.name", fieldConfig.name);
 				try {
 					return await runFilters(span);
+				} catch (error) {
+					this.logger?.error({
+						"graphql.field.name": fieldConfig.name,
+						err: error
+					}, "runtime filter threw");
+					throw error;
 				} finally {
 					span.end();
 				}
 			});
-			else return runFilters();
+			else try {
+				return await runFilters();
+			} catch (error) {
+				this.logger?.error({
+					"graphql.field.name": fieldConfig.name,
+					err: error
+				}, "runtime filter threw");
+				throw error;
+			}
 		};
 	}
 };
@@ -1809,7 +2127,7 @@ function registerRuntimeFiltersPlugin() {
 }
 //#endregion
 //#region lib/schemaBuilder.ts
-const createSchemaBuilder = ({ db, disableDefaultObjects, pubsub, pothosConfig, otel }) => {
+const createSchemaBuilder = ({ db, pubsub, pothosConfig, otel, logger }) => {
 	const createSpan = otel?.enabled && otel.tracer ? createOpenTelemetryWrapper(otel.tracer, otel.options) : void 0;
 	registerRuntimeFiltersPlugin();
 	const schemaBuilder = new SchemaBuilder({
@@ -1837,18 +2155,40 @@ const createSchemaBuilder = ({ db, disableDefaultObjects, pubsub, pothosConfig,
 		}) },
 		defaultFieldNullability: false,
 		tracing: {
-			default: otel?.enabled ? (config) => isRootField(config) : () => false,
-			wrap: createSpan ? (resolver, options) => createSpan(resolver, options) : (resolver) => resolver
+			default: otel?.enabled || logger?.enabled ? (config) => isRootField(config) : () => false,
+			wrap: (resolver, options, config) => {
+				let r = createSpan ? createSpan(resolver, options) : resolver;
+				if (logger?.enabled) {
+					const log = logger.logger;
+					r = wrapResolver(r, (error, duration) => {
+						if (error) log.error({
+							"graphql.field.name": config.name,
+							"graphql.parent.type": config.parentType,
+							durationMs: duration,
+							err: error
+						}, "resolver failed");
+						else log.debug({
+							"graphql.field.name": config.name,
+							"graphql.parent.type": config.parentType,
+							durationMs: duration
+						}, "resolver completed");
+					});
+				}
+				return r;
+			}
 		},
-		otel
+		otel,
+		logger
 	});
 	schemaBuilder.addScalarType("JSON", JSONResolver);
 	schemaBuilder.addScalarType("Date", DateResolver);
 	schemaBuilder.addScalarType("DateTime", DateTimeISOResolver);
+	schemaBuilder.addScalarType("BigInt", BigIntResolver);
+	schemaBuilder.addScalarType("Bytes", ByteResolver);
 	implementDefaultWhereInputArgs(schemaBuilder);
-	if (!disableDefaultObjects?.query) schemaBuilder.queryType({});
-	if (!disableDefaultObjects?.subscription) schemaBuilder.subscriptionType({});
-	if (!disableDefaultObjects?.mutation) schemaBuilder.mutationType({});
+	schemaBuilder.queryType({});
+	schemaBuilder.subscriptionType({});
+	schemaBuilder.mutationType({});
 	return { schemaBuilder };
 };
 //#endregion
@@ -1931,7 +2271,33 @@ export const r = rumble({
 		whereArgImplementer: whereArg,
 		makePubSubInstance
 	});
-	const builtSchema = lazy(() => schemaBuilder.toSchema());
+	const builtSchema = lazy(() => {
+		let raw;
+		try {
+			raw = schemaBuilder.toSchema();
+		} catch (e) {
+			const unimplMatch = (e?.message ?? String(e)).match(/ObjectRef<(.+?)> has not been implemented/);
+			if (unimplMatch) throw new RumbleError(`Could not build GraphQL schema: the table "${unimplMatch[1]}" is referenced in a relation but has not been registered. Call rumble.object({ table: "${unimplMatch[1]}" }) before building the schema.`);
+			throw e;
+		}
+		const mutation = raw.getMutationType();
+		const subscription = raw.getSubscriptionType();
+		const emptyMutation = mutation && Object.keys(mutation.getFields()).length === 0;
+		const emptySubscription = subscription && Object.keys(subscription.getFields()).length === 0;
+		if (!emptyMutation && !emptySubscription) return raw;
+		const config = raw.toConfig();
+		const filteredTypes = config.types.filter((t) => {
+			if (emptyMutation && t === mutation) return false;
+			if (emptySubscription && t === subscription) return false;
+			return true;
+		});
+		return new GraphQLSchema({
+			...config,
+			mutation: emptyMutation ? void 0 : config.mutation,
+			subscription: emptySubscription ? void 0 : config.subscription,
+			types: filteredTypes
+		});
+	});
 	const createYoga$1 = (args) => {
 		const enableApiDocs = args?.enableApiDocs ?? process?.env?.NODE_ENV === "development";
 		return createYoga({
@@ -1942,26 +2308,60 @@ export const r = rumble({
 			plugins: [
 				...args?.plugins ?? [],
 				...enableApiDocs ? [] : [useDisableIntrospection(), EnvelopArmorPlugin(args?.armorConfig)],
-				rumbleInput.otel?.enabled ? { onExecute: ({ setExecuteFn, executeFn }) => {
-					setExecuteFn((options) => rumbleInput.otel.tracer.startActiveSpan(SpanNames.EXECUTE, { attributes: {
-						[AttributeNames.OPERATION_NAME]: options.operationName ?? "anonymous",
-						[AttributeNames.SOURCE]: options.document
-					} }, async (span) => {
-						try {
+				rumbleInput.otel?.enabled || rumbleInput.logger?.enabled ? { onExecute: ({ setExecuteFn, executeFn }) => {
+					setExecuteFn(async (options) => {
+						const log = rumbleInput.logger?.enabled ? rumbleInput.logger.logger : void 0;
+						const operationName = options.operationName ?? "anonymous";
+						const start = Date.now();
+						log?.info({ "graphql.operation.name": operationName }, "graphql execute start");
+						const run = async () => {
 							const result = await executeFn(options);
-							if (result && "errors" in result && result.errors?.length) {
-								for (const error of result.errors) span.recordException(error);
+							if (result && "errors" in result && result.errors?.length) log?.error({
+								"graphql.operation.name": operationName,
+								durationMs: Date.now() - start,
+								errors: result.errors.map((e) => e.message)
+							}, "graphql execute completed with errors");
+							else log?.info({
+								"graphql.operation.name": operationName,
+								durationMs: Date.now() - start
+							}, "graphql execute completed");
+							return result;
+						};
+						if (rumbleInput.otel?.enabled) return rumbleInput.otel.tracer.startActiveSpan(SpanNames.EXECUTE, { attributes: {
+							[AttributeNames.OPERATION_NAME]: operationName,
+							[AttributeNames.SOURCE]: options.document
+						} }, async (span) => {
+							try {
+								const result = await run();
+								if (result && "errors" in result && result.errors?.length) {
+									for (const error of result.errors) span.recordException(error);
+									span.setStatus({ code: SpanStatusCode.ERROR });
+								}
+								return result;
+							} catch (error) {
+								if (error instanceof Error) span.recordException(error);
+								log?.error({
+									"graphql.operation.name": operationName,
+									durationMs: Date.now() - start,
+									err: error
+								}, "graphql execute threw");
 								span.setStatus({ code: SpanStatusCode.ERROR });
+								throw error;
+							} finally {
+								span.end();
 							}
-							return result;
+						});
+						try {
+							return await run();
 						} catch (error) {
-							if (error instanceof Error) span.recordException(error);
-							span.setStatus({ code: SpanStatusCode.ERROR });
+							log?.error({
+								"graphql.operation.name": operationName,
+								durationMs: Date.now() - start,
+								err: error
+							}, "graphql execute threw");
 							throw error;
-						} finally {
-							span.end();
 						}
-					}));
+					});
 				} } : false
 			].filter(Boolean)
 		});