@m1212e/rumble 0.11.7 → 0.12.1

package/out/index.js

@@ -0,0 +1,1849 @@
+import { access, mkdir, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { GraphQLEnumType, GraphQLError, GraphQLInputObjectType, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLScalarType } from "graphql";
+import { capitalize, cloneDeep, debounce, merge, toMerged } from "es-toolkit";
+import { empty, fromValue, map, merge as merge$1, onPush, pipe, toObservable, toPromise } from "wonka";
+import { EnvelopArmorPlugin } from "@escape.tech/graphql-armor";
+import { useDisableIntrospection } from "@graphql-yoga/plugin-disable-introspection";
+import { createPubSub, createYoga } from "graphql-yoga";
+import { useSofa } from "sofa-api";
+import { One, relationsFilterToSQL, sql } from "drizzle-orm";
+import { toCamelCase } from "drizzle-orm/casing";
+import { PgEnumColumn, PgTable } from "drizzle-orm/pg-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 { DateResolver, DateTimeISOResolver, JSONResolver } from "graphql-scalars";
+
+//#region lib/client/generate/client.ts
+function generateClient({ apiUrl, rumbleImportPath, useExternalUrqlClient, availableSubscriptions }) {
+	const imports = [];
+	let code = "";
+	if (typeof useExternalUrqlClient === "string") imports.push(`import { urqlClient } from "${useExternalUrqlClient}";`);
+	else {
+		imports.push(`import { Client, fetchExchange } from '@urql/core';`);
+		imports.push(`import { cacheExchange } from '@urql/exchange-graphcache';`);
+	}
+	imports.push(`import { makeLiveQuery, makeMutation, makeSubscription, makeQuery } from '${rumbleImportPath}';`);
+	if (!useExternalUrqlClient) code += `
+const urqlClient = new Client({
+  url: "${apiUrl ?? "PLEASE PROVIDE A URL WHEN GENERATING OR IMPORT AN EXTERNAL URQL CLIENT"}",
+  fetchSubscriptions: true,
+  exchanges: [cacheExchange({}), fetchExchange],
+  fetchOptions: {
+    credentials: "include",
+  },
+  requestPolicy: "cache-and-network",
+});
+`;
+	code += `
+export const client = {
+  /**
+   * A query and subscription combination. First queries and if exists, also subscribes to a subscription of the same name.
+   * Combines the results of both, so the result is first the query result and then live updates from the subscription.
+   * Assumes that the query and subscription return the same fields as per default when using the rumble query helpers.
+   * If no subscription with the same name exists, this will just be a query.
+   */
+  liveQuery: makeLiveQuery<Query>({
+	  urqlClient,
+	  availableSubscriptions: new Set([${availableSubscriptions.values().toArray().map((value) => `"${value}"`).join(", ")}]),
+  }),
+  /**
+   * A mutation that can be used to e.g. create, update or delete data.
+   */
+  mutate: makeMutation<Mutation>({
+	  urqlClient,
+  }),
+  /**
+   * A continuous stream of results that updates when the server sends new data.
+   */
+  subscribe: makeSubscription<Subscription>({
+	  urqlClient,
+  }),
+  /**
+   * A one-time fetch of data.
+   */
+  query: makeQuery<Query>({
+	  urqlClient,
+  }),
+}`;
+	return {
+		imports,
+		code
+	};
+}
+
+//#endregion
+//#region lib/client/generate/tsRepresentation.ts
+function makeTSRepresentation(model) {
+	if (model instanceof GraphQLObjectType) return makeTSTypeFromObject(model);
+	else if (model instanceof GraphQLScalarType) return mapGraphqlScalarToTSTypeString(model);
+	else if (model instanceof GraphQLEnumType) return makeStringLiteralUnionFromEnum(model);
+	else if (model instanceof GraphQLInputObjectType) return makeTSTypeFromInputObject(model);
+	throw new Error(`Unknown model type: ${model}`);
+}
+function makeTSTypeFromObject(model) {
+	const stringifiedFields = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(model.getFields())) stringifiedFields.set(key, makeTSObjectTypeField(value.type, value.args));
+	return `{
+  ${stringifiedFields.entries().map(([key, value]) => `${key}: ${value}`).toArray().join(",\n  ")}    
+}`;
+}
+function makeTSTypeFromInputObject(model) {
+	const stringifiedFields = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(model.getFields())) stringifiedFields.set(key, makeTSInputObjectTypeField(value.type));
+	return `{
+  ${stringifiedFields.entries().map(([key, value]) => `${key}${value.includes("| undefined") ? "?" : ""}: ${value}`).toArray().join(",\n  ")}    
+}`;
+}
+function makeTSObjectTypeField(returnType, args) {
+	let isNonNullReturnType = false;
+	let isList = false;
+	for (let index = 0; index < 3; index++) {
+		if (returnType instanceof GraphQLList) {
+			isList = true;
+			returnType = returnType.ofType;
+		}
+		if (returnType instanceof GraphQLNonNull) {
+			isNonNullReturnType = true;
+			returnType = returnType.ofType;
+		}
+	}
+	let returnTypeString = returnType.name;
+	if (isList) returnTypeString += "[]";
+	if (!isNonNullReturnType) returnTypeString += " | null";
+	const isRelationType = returnType instanceof GraphQLObjectType;
+	const argsStringMap = /* @__PURE__ */ new Map();
+	for (const arg of args ?? []) argsStringMap.set(arg.name, stringifyTSObjectArg(arg.type));
+	if (isRelationType) {
+		const makePOptional = argsStringMap.entries().every(([, value]) => value.includes("| undefined"));
+		return `(${(args ?? []).length > 0 ? `p${makePOptional ? "?" : ""}: {
+  ${argsStringMap.entries().map(([key, value]) => `  ${key}${value.includes("| undefined") ? "?" : ""}: ${value}`).toArray().join(",\n  ")}
+  }` : ""}) => ${returnTypeString}`;
+	} else return returnTypeString;
+}
+function makeTSInputObjectTypeField(returnType) {
+	let isNonNullReturnType = false;
+	let isList = false;
+	for (let index = 0; index < 3; index++) {
+		if (returnType instanceof GraphQLList) {
+			isList = true;
+			returnType = returnType.ofType;
+		}
+		if (returnType instanceof GraphQLNonNull) {
+			isNonNullReturnType = true;
+			returnType = returnType.ofType;
+		}
+	}
+	let returnTypeString = returnType.name;
+	if (isList) returnTypeString += "[]";
+	if (!isNonNullReturnType) returnTypeString += " | null | undefined";
+	else if (isList) returnTypeString += " | undefined";
+	return returnTypeString;
+}
+function stringifyTSObjectArg(arg) {
+	let ret = "unknown";
+	let isNullable = true;
+	if (arg instanceof GraphQLNonNull) {
+		isNullable = false;
+		arg = arg.ofType;
+	}
+	if (arg instanceof GraphQLInputObjectType || arg instanceof GraphQLScalarType) ret = arg.name;
+	if (isNullable) ret += " | null | undefined";
+	return ret;
+}
+function mapGraphqlScalarToTSTypeString(arg) {
+	switch (arg.name) {
+		case "ID": return "string";
+		case "String": return "string";
+		case "Boolean": return "boolean";
+		case "Int": return "number";
+		case "Float": return "number";
+		case "Date": return "Date";
+		case "DateTime": return "Date";
+		case "JSON": return "any";
+		default: return "unknown";
+	}
+}
+function makeStringLiteralUnionFromEnum(enumType) {
+	return enumType.getValues().map((value) => `"${value.name}"`).join(" | ");
+}
+
+//#endregion
+//#region lib/client/generate/generate.ts
+async function generateFromSchema({ outputPath, schema, rumbleImportPath = "@m1212e/rumble", apiUrl, useExternalUrqlClient = false }) {
+	try {
+		await access(outputPath);
+		await rm(outputPath, {
+			recursive: true,
+			force: true
+		});
+	} catch (_error) {}
+	await mkdir(outputPath, { recursive: true });
+	if (!outputPath.endsWith("/")) outputPath += "/";
+	const imports = [];
+	let code = "";
+	const typeMap = /* @__PURE__ */ new Map();
+	for (const [key, object] of Object.entries(schema.getTypeMap())) {
+		if (key.startsWith("__")) continue;
+		typeMap.set(key, object);
+	}
+	for (const [key, object] of typeMap.entries()) {
+		const rep = makeTSRepresentation(object);
+		if (rep === key) continue;
+		code += `
+export type ${key} = ${rep};
+		`;
+	}
+	const c = generateClient({
+		apiUrl,
+		useExternalUrqlClient,
+		rumbleImportPath,
+		availableSubscriptions: new Set(Object.keys(schema.getSubscriptionType()?.getFields() || {}))
+	});
+	imports.push(...c.imports);
+	code += c.code;
+	await writeFile(join(outputPath, "client.ts"), `${imports.join("\n")}\n${code}`);
+}
+
+//#endregion
+//#region lib/client/request.ts
+const argsKey = "__args";
+function makeGraphQLQuery({ queryName, input, client, enableSubscription = false }) {
+	const otwQueryName = `${capitalize(queryName)}Query`;
+	const argsString = stringifyArgumentObjectToGraphqlList(input[argsKey] ?? {});
+	const operationString = (operationVerb) => `${operationVerb} ${otwQueryName} { ${queryName}${argsString} { ${stringifySelection(input)} }}`;
+	let awaitedReturnValueReference;
+	const response = pipe(merge$1([client.query(operationString("query"), {}), enableSubscription ? client.subscription(operationString("subscription"), {}) : empty]), map((v) => {
+		const data = v.data?.[queryName];
+		if (!data && v.error) throw v.error;
+		return data;
+	}), onPush((data) => {
+		if (awaitedReturnValueReference) Object.assign(awaitedReturnValueReference, data);
+	}));
+	const promise = new Promise((resolve) => {
+		const unsub = toObservable(response).subscribe((v) => {
+			unsub();
+			const newObservableWithAwaitedValue = pipe(merge$1([response, fromValue(v)]), toObservable);
+			awaitedReturnValueReference = {
+				...v,
+				...newObservableWithAwaitedValue
+			};
+			resolve(awaitedReturnValueReference);
+		}).unsubscribe;
+	});
+	Object.assign(promise, toObservable(response));
+	return promise;
+}
+function makeGraphQLMutation({ mutationName, input, client }) {
+	const otwMutationName = `${capitalize(mutationName)}Mutation`;
+	const argsString = stringifyArgumentObjectToGraphqlList(input[argsKey] ?? {});
+	const response = pipe(client.mutation(`mutation ${otwMutationName} { ${mutationName}${argsString} { ${stringifySelection(input)} }}`, {}), map((v) => {
+		const data = v.data?.[mutationName];
+		if (!data && v.error) throw v.error;
+		return data;
+	}));
+	const observable = toObservable(response);
+	const promise = toPromise(response).then((res) => {
+		Object.assign(res, observable);
+		return res;
+	});
+	Object.assign(promise, observable);
+	return promise;
+}
+function makeGraphQLSubscription({ subscriptionName, input, client }) {
+	const otwSubscriptionName = `${capitalize(subscriptionName)}Subscription`;
+	const argsString = stringifyArgumentObjectToGraphqlList(input[argsKey] ?? {});
+	return pipe(client.subscription(`subscription ${otwSubscriptionName} { ${subscriptionName}${argsString} { ${stringifySelection(input)} }}`, {}), map((v) => {
+		const data = v.data?.[subscriptionName];
+		if (!data && v.error) throw v.error;
+		return data;
+	}), toObservable);
+}
+function stringifySelection(selection) {
+	return Object.entries(selection).filter(([key]) => key !== argsKey).reduce((acc, [key, value]) => {
+		if (typeof value === "object") {
+			if (value[argsKey]) {
+				const argsString = stringifyArgumentObjectToGraphqlList(value[argsKey]);
+				acc += `${key}${argsString} { ${stringifySelection(value)} }
+`;
+				return acc;
+			}
+			acc += `${key} { ${stringifySelection(value)} }
+`;
+		} else acc += `${key}
+`;
+		return acc;
+	}, "");
+}
+function stringifyArgumentObjectToGraphqlList(args) {
+	const entries = Object.entries(args);
+	if (entries.length === 0) return "";
+	return `(${entries.map(([key, value]) => `${key}: ${stringifyArgumentValue(value)}`).join(", ")})`;
+}
+function stringifyArgumentValue(arg) {
+	switch (typeof arg) {
+		case "string": return `"${arg}"`;
+		case "number": return `${arg}`;
+		case "bigint": return `${arg}`;
+		case "boolean": return `${arg}`;
+		case "symbol": throw new Error("Cannot stringify a symbol to send as gql arg");
+		case "undefined": return "null";
+		case "object": return `{ ${Object.entries(arg).map(([key, value]) => `${key}: ${stringifyArgumentValue(value)}`).join(", ")} }`;
+		case "function": throw new Error("Cannot stringify a function to send as gql arg");
+	}
+}
+
+//#endregion
+//#region lib/client/liveQuery.ts
+function makeLiveQuery({ urqlClient, availableSubscriptions }) {
+	return new Proxy({}, { get: (_target, prop) => {
+		return (input) => {
+			return makeGraphQLQuery({
+				queryName: prop,
+				input,
+				client: urqlClient,
+				enableSubscription: availableSubscriptions.has(prop)
+			});
+		};
+	} });
+}
+
+//#endregion
+//#region lib/client/mutation.ts
+function makeMutation({ urqlClient }) {
+	return new Proxy({}, { get: (_target, prop) => {
+		return (input) => {
+			return makeGraphQLMutation({
+				mutationName: prop,
+				input,
+				client: urqlClient
+			});
+		};
+	} });
+}
+
+//#endregion
+//#region lib/client/query.ts
+function makeQuery({ urqlClient }) {
+	return new Proxy({}, { get: (_target, prop) => {
+		return (input) => {
+			return makeGraphQLQuery({
+				queryName: prop,
+				input,
+				client: urqlClient,
+				enableSubscription: false
+			});
+		};
+	} });
+}
+
+//#endregion
+//#region lib/client/subscription.ts
+function makeSubscription({ urqlClient }) {
+	return new Proxy({}, { get: (_target, prop) => {
+		return (input) => {
+			return makeGraphQLSubscription({
+				subscriptionName: prop,
+				input,
+				client: urqlClient
+			});
+		};
+	} });
+}
+
+//#endregion
+//#region lib/types/rumbleError.ts
+/**
+* An error that gets raised by rumble whenever something does not go according to plan.
+* Mostly internals, configuration errors or other unexpected things.
+*/
+var RumbleError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "RumbleError";
+	}
+};
+/**
+* An error that gets raised by rumble whenever an error occurs in a resolver, containing
+* information safely exposeable to the user.
+* E.g. the assert helpers issue these.
+*/
+var RumbleErrorSafe = class extends GraphQLError {};
+
+//#endregion
+//#region lib/helpers/asserts.ts
+/**
+* 
+* Helper function to map a drizzle findFirst query result,
+* which may be optional, to a correct drizzle type.
+* 
+* @throws RumbleError
+* 
+* @example
+* 
+* ```ts
+* schemaBuilder.queryFields((t) => {
+return {
+findFirstUser: t.drizzleField({
+type: UserRef,
+resolve: (query, root, args, ctx, info) => {
+return (
+db.query.users
+.findFirst({
+...query,
+where: ctx.abilities.users.filter("read").single.where,
+})
+// note that we need to manually raise an error if the value is not found
+.then(assertFindFirstExists)
+);
+},
+}),
+};
+});
+* ```
+*/
+const assertFindFirstExists = (value) => {
+	if (!value) throw new RumbleErrorSafe("Value not found but required (findFirst)");
+	return value;
+};
+/**
+* 
+* Helper function to map a drizzle findFirst query result,
+* which may be optional, to a correct drizzle type.
+* 
+* @throws RumbleError
+* 
+* @example
+* 
+* ```ts
+schemaBuilder.mutationFields((t) => {
+return {
+updateUsername: t.drizzleField({
+type: UserRef,
+args: {
+userId: t.arg.int({ required: true }),
+newName: t.arg.string({ required: true }),
+},
+resolve: (query, root, args, ctx, info) => {
+return db
+.update(schema.users)
+.set({
+name: args.newName,
+})
+.where(
+and(
+eq(schema.users.id, args.userId),
+ctx.abilities.users.filter("update").single.where
+)
+)
+.returning({ id: schema.users.id, name: schema.users.name })
+// note that we need to manually raise an error if the value is not found
+.then(assertFirstEntryExists);
+},
+}),
+};
+});
+* ```
+*/
+const assertFirstEntryExists = (value) => {
+	const v = value.at(0);
+	if (!v) throw new RumbleErrorSafe("Value not found but required (firstEntry)");
+	return v;
+};
+
+//#endregion
+//#region lib/helpers/mapNullFieldsToUndefined.ts
+/**
+* Helper to map null fields to undefined
+* @param obj The object to map
+* @returns The mapped object with all fields of 'null' transformed to 'undefined'
+* 
+* This becomes useful for update mutations where you do not want to pass null (unset value in db)
+* but undefined (do not touch value in db) in case of a value not beeing set in the args of said mutation
+* @example
+* ```ts
+*  updateUser: t.drizzleField({
+type: User,
+args: {
+id: t.arg.string({ required: true }),
+email: t.arg.string(),
+lastName: t.arg.string(),
+firstName: t.arg.string(),
+},
+resolve: async (query, root, args, ctx, info) => {
+const mappedArgs = mapNullFieldsToUndefined(args);
+const user = await db.transaction(async (tx) => {
+const user = await tx
+.update(schema.user)
+.set({
+
+// email: args.email ?? undefined,
+// lastName: args.lastName ?? undefined,
+// firstName: args.firstName ?? undefined,
+
+// becomes this
+
+email: mappedArgs.email,
+lastName: mappedArgs.lastName,
+firstName: mappedArgs.firstName,
+})
+.returning()
+.then(assertFirstEntryExists);
+return user;
+});
+
+pubsub.updated(user.id);
+
+return db.query.user
+.findFirst(
+query(
+ctx.abilities.user.filter('read').merge(
+{
+where: { id: user.id },
+}
+1).query.single,
+),
+)
+.then(assertFindFirstExists);
+},
+}),
+* 
+* 
+* ```
+*/
+function mapNullFieldsToUndefined(obj) {
+	return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, value === null ? void 0 : value]));
+}
+
+//#endregion
+//#region lib/helpers/lazy.ts
+/**
+* Creates a lazily initialized function.
+*
+* The returned function will call the initializer function on its first call and
+* store the result. On subsequent calls, it will return the stored result.
+*
+* @param initializer The function to be called for initialization.
+* @returns A function that calls the initializer function on its first call and
+*          returns the stored result on subsequent calls.
+*/
+function lazy(initializer) {
+	let value;
+	let initialized = false;
+	return () => {
+		if (!initialized) {
+			value = initializer();
+			initialized = true;
+		}
+		return value;
+	};
+}
+
+//#endregion
+//#region lib/helpers/mergeFilters.ts
+function mergeFilters(filterA, filterB) {
+	return {
+		where: filterA?.where && filterB?.where ? { AND: [filterA?.where, filterB?.where] } : filterA?.where ?? filterB?.where,
+		columns: filterA?.columns || filterB?.columns ? new Set([Object.entries(filterA?.columns ?? {}), Object.entries(filterB?.columns ?? {})].flat().filter(([, v]) => v === true).map(([k]) => k)).entries().reduce((acc, [key]) => {
+			acc[key] = true;
+			return acc;
+		}, {}) : void 0,
+		extras: filterA?.extras || filterB?.extras ? toMerged(filterA?.extras ?? {}, filterB?.extras ?? {}) : void 0,
+		orderBy: filterA?.orderBy || filterB?.orderBy ? toMerged(filterA?.orderBy ?? {}, filterB?.orderBy ?? {}) : void 0,
+		limit: filterA?.limit || filterB?.limit ? Math.min(filterA?.limit ?? Infinity, filterB?.limit ?? Infinity) : void 0,
+		offset: filterA?.offset || filterB?.offset ? Math.min(filterA?.offset ?? Infinity, filterB?.offset ?? Infinity) : void 0,
+		with: filterA?.with || filterB?.with ? toMerged(filterA?.with ?? {}, filterB?.with ?? {}) : void 0
+	};
+}
+
+//#endregion
+//#region lib/helpers/sqlTypes/types.ts
+const intLikeSQLTypeStrings = [
+	"serial",
+	"int",
+	"integer",
+	"tinyint",
+	"smallint",
+	"mediumint"
+];
+function isIntLikeSQLTypeString(sqlType) {
+	return intLikeSQLTypeStrings.includes(sqlType);
+}
+const floatLikeSQLTypeStrings = [
+	"real",
+	"decimal",
+	"double",
+	"float",
+	"numeric"
+];
+function isFloatLikeSQLTypeString(sqlType) {
+	return floatLikeSQLTypeStrings.includes(sqlType);
+}
+const stringLikeSQLTypeStrings = [
+	"string",
+	"text",
+	"varchar",
+	"char",
+	"text(256)"
+];
+function isStringLikeSQLTypeString(sqlType) {
+	return stringLikeSQLTypeStrings.includes(sqlType);
+}
+const IDLikeSQLTypeStrings = ["uuid"];
+function isIDLikeSQLTypeString(sqlType) {
+	return IDLikeSQLTypeStrings.includes(sqlType);
+}
+const booleanSQLTypeStrings = ["boolean"];
+function isBooleanSQLTypeString(sqlType) {
+	return booleanSQLTypeStrings.includes(sqlType);
+}
+const dateTimeLikeSQLTypeStrings = ["timestamp", "datetime"];
+function isDateTimeLikeSQLTypeString(sqlType) {
+	return dateTimeLikeSQLTypeStrings.includes(sqlType);
+}
+const dateLikeSQLTypeStrings = ["date"];
+function isDateLikeSQLTypeString(sqlType) {
+	return dateLikeSQLTypeStrings.includes(sqlType);
+}
+const jsonLikeSQLTypeStrings = ["json"];
+function isJSONLikeSQLTypeString(sqlType) {
+	return jsonLikeSQLTypeStrings.includes(sqlType);
+}
+[
+	...intLikeSQLTypeStrings,
+	...floatLikeSQLTypeStrings,
+	...stringLikeSQLTypeStrings,
+	...IDLikeSQLTypeStrings,
+	...booleanSQLTypeStrings,
+	...dateTimeLikeSQLTypeStrings,
+	...dateLikeSQLTypeStrings,
+	...jsonLikeSQLTypeStrings
+];
+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
+function createDistinctValuesFromSQLType(sqlType) {
+	if (isIntLikeSQLTypeString(sqlType)) return {
+		value1: 1,
+		value2: 2
+	};
+	if (isFloatLikeSQLTypeString(sqlType)) return {
+		value1: 1.1,
+		value2: 2.2
+	};
+	if (isStringLikeSQLTypeString(sqlType)) return {
+		value1: "a",
+		value2: "b"
+	};
+	if (isIDLikeSQLTypeString(sqlType)) return {
+		value1: "fba31870-5528-42d7-b27e-2e5ee657aea5",
+		value2: "fc65db81-c2d1-483d-8a25-a30e2cf6e02d"
+	};
+	if (isBooleanSQLTypeString(sqlType)) return {
+		value1: true,
+		value2: false
+	};
+	if (isDateTimeLikeSQLTypeString(sqlType)) return {
+		value1: new Date(2022, 1, 1),
+		value2: new Date(2022, 1, 2)
+	};
+	if (isDateLikeSQLTypeString(sqlType)) return {
+		value1: new Date(2022, 1, 1),
+		value2: new Date(2022, 1, 2)
+	};
+	if (isJSONLikeSQLTypeString(sqlType)) return {
+		value1: { a: 1 },
+		value2: { b: 2 }
+	};
+	throw UnknownTypeRumbleError(sqlType, "Distinct");
+}
+
+//#endregion
+//#region lib/helpers/tableHelpers.ts
+const drizzleNameSymbol = Symbol.for("drizzle:Name");
+const drizzleOriginalNameSymbol = Symbol.for("drizzle:OriginalName");
+const drizzleBaseNameSymbol = Symbol.for("drizzle:BaseName");
+function tableHelper({ db, table }) {
+	if (typeof table !== "string") table = table.tsName || table.dbName || table[drizzleNameSymbol] || table[drizzleOriginalNameSymbol] || table[drizzleBaseNameSymbol];
+	const foundRelation = Object.values(db._.relations).find((schema) => schema.name === table || schema.table[drizzleNameSymbol] === table || schema.table[drizzleOriginalNameSymbol] === table || schema.table[drizzleBaseNameSymbol] === table);
+	if (!foundRelation) throw new RumbleError(`Could not find schema for ${JSON.stringify(table)}`);
+	const foundSchema = Object.values(db._.schema).find((schema) => schema.dbName === foundRelation.table[drizzleOriginalNameSymbol]);
+	if (!foundSchema) throw new RumbleError(`Could not find schema for ${JSON.stringify(table)}`);
+	return {
+		columns: foundSchema.columns,
+		primaryKey: foundSchema.primaryKey,
+		relations: foundRelation.relations,
+		dbName: foundSchema.dbName,
+		tsName: foundSchema.tsName,
+		foundSchema,
+		foundRelation
+	};
+}
+
+//#endregion
+//#region lib/abilityBuilder.ts
+function isDynamicQueryFilter(filter) {
+	return typeof filter === "function" && filter.constructor.name !== "AsyncFunction";
+}
+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.
+`);
+}, 1e3);
+const createAbilityBuilder = ({ db, actions, defaultLimit }) => {
+	let hasBeenBuilt = false;
+	const createBuilderForTable = () => {
+		const queryFilters = /* @__PURE__ */ new Map();
+		const runtimeFilters = /* @__PURE__ */ new Map();
+		for (const action of actions) if (!runtimeFilters.has(action)) runtimeFilters.set(action, []);
+		return {
+			allow: (action) => {
+				if (hasBeenBuilt) throw new RumbleError("You can't call allow() after the ability builder has been built. Please ensure that you register all abilities before accessing them.");
+				const actions$1 = Array.isArray(action) ? action : [action];
+				for (const action$1 of actions$1) {
+					let filters = queryFilters.get(action$1);
+					if (!filters) {
+						filters = "unrestricted";
+						queryFilters.set(action$1, filters);
+					}
+				}
+				return { when: (queryFilter) => {
+					for (const action$1 of actions$1) {
+						if (queryFilters.get(action$1) === "unrestricted") queryFilters.set(action$1, []);
+						queryFilters.get(action$1).push(queryFilter);
+					}
+				} };
+			},
+			filter: (action) => {
+				const actions$1 = Array.isArray(action) ? action : [action];
+				return { by: (explicitFilter) => {
+					for (const action$1 of actions$1) runtimeFilters.get(action$1).push(explicitFilter);
+				} };
+			},
+			_: {
+				runtimeFilters,
+				queryFilters
+			}
+		};
+	};
+	const buildersPerTable = Object.fromEntries(Object.keys(db.query).map((tableName) => [tableName, createBuilderForTable()]));
+	return {
+		...buildersPerTable,
+		_: {
+			registeredFilters({ action, table }) {
+				return buildersPerTable[table]._.runtimeFilters.get(action);
+			},
+			build() {
+				const createFilterForTable = (tableName) => {
+					const queryFilters = buildersPerTable[tableName]._.queryFilters;
+					const simpleQueryFilters = Object.fromEntries(actions.map((action) => {
+						const filters = queryFilters.get(action);
+						if (!filters || filters === "unrestricted") return [action, []];
+						return [action, filters.filter(isStaticQueryFilter)];
+					}));
+					const dynamicQueryFilters = Object.fromEntries(actions.map((action) => {
+						const filters = queryFilters.get(action);
+						if (!filters || filters === "unrestricted") return [action, []];
+						return [action, filters.filter(isDynamicQueryFilter)];
+					}));
+					const tableSchema = tableHelper({
+						db,
+						table: tableName
+					});
+					if (Object.keys(tableSchema.primaryKey).length === 0) throw new RumbleError(`No primary key found for entity ${tableName.toString()}`);
+					const primaryKeyField = Object.values(tableSchema.primaryKey)[0];
+					const distinctValues = createDistinctValuesFromSQLType(primaryKeyField.getSQLType());
+					const blockEverythingFilter = { where: { AND: [{ [primaryKeyField.name]: distinctValues.value1 }, { [primaryKeyField.name]: distinctValues.value2 }] } };
+					/**
+					* Packs the filters into a response object that can be applied for queries by the user
+					*/
+					function transformToResponse(queryFilters$1) {
+						const internalTransformer = (filters, mergedLimit) => {
+							const limit = lazy(() => {
+								if (mergedLimit !== void 0) {
+									if (!filters?.limit) return mergedLimit;
+									if (filters.limit > mergedLimit) return mergedLimit;
+								}
+								let limit$1 = filters?.limit;
+								if (defaultLimit && (limit$1 === void 0 || limit$1 > defaultLimit)) limit$1 = defaultLimit;
+								return limit$1 ?? void 0;
+							});
+							const sqlTransformedWhere = lazy(() => {
+								return filters?.where ? relationsFilterToSQL(tableSchema.foundRelation.table, filters.where) : void 0;
+							});
+							if (filters?.columns) return {
+								query: {
+									single: {
+										where: filters?.where,
+										columns: filters?.columns
+									},
+									many: {
+										where: filters?.where,
+										columns: filters?.columns,
+										get limit() {
+											return limit();
+										}
+									}
+								},
+								sql: { get where() {
+									return sqlTransformedWhere();
+								} }
+							};
+							else return {
+								query: {
+									single: { where: filters?.where },
+									many: {
+										where: filters?.where,
+										get limit() {
+											return limit();
+										}
+									}
+								},
+								sql: { get where() {
+									return sqlTransformedWhere();
+								} }
+							};
+						};
+						const ret = internalTransformer(queryFilters$1);
+						/**
+						* Merges the current query filters with the provided filters for this call only
+						*/
+						function merge$2(p) {
+							return internalTransformer(mergeFilters(ret.query.many, p), p.limit);
+						}
+						ret.merge = merge$2;
+						return ret;
+					}
+					return { withContext: (userContext) => {
+						return { filter: (action) => {
+							const filters = queryFilters.get(action);
+							if (filters === "unrestricted") return transformToResponse();
+							if (!filters) {
+								nothingRegisteredWarningLogger(tableName.toString(), action);
+								return transformToResponse(blockEverythingFilter);
+							}
+							const dynamicResults = new Array(dynamicQueryFilters[action].length);
+							let filtersReturned = 0;
+							for (let i = 0; i < dynamicQueryFilters[action].length; i++) {
+								const func = dynamicQueryFilters[action][i];
+								const result = func(userContext);
+								if (result === "allow") return transformToResponse();
+								if (result === void 0) continue;
+								dynamicResults[filtersReturned++] = result;
+							}
+							dynamicResults.length = filtersReturned;
+							const allQueryFilters = [...simpleQueryFilters[action], ...dynamicResults];
+							if (allQueryFilters.length === 0) return transformToResponse(blockEverythingFilter);
+							return transformToResponse(allQueryFilters.length === 1 ? allQueryFilters[0] : allQueryFilters.reduce((a, b) => {
+								return mergeFilters(a, b);
+							}, {}));
+						} };
+					} };
+				};
+				const abilitiesPerTable = Object.fromEntries(Object.keys(db.query).map((tableName) => [tableName, createFilterForTable(tableName)]));
+				hasBeenBuilt = true;
+				return (ctx) => {
+					return Object.fromEntries(Object.keys(abilitiesPerTable).map((tableName) => [tableName, abilitiesPerTable[tableName].withContext(ctx)]));
+				};
+			}
+		}
+	};
+};
+
+//#endregion
+//#region lib/args/orderArg.ts
+const makeDefaultName$1 = (dbName) => `${capitalize(toCamelCase(dbName.toString()))}OrderInputArgument`;
+const createOrderArgImplementer = ({ db, schemaBuilder }) => {
+	const referenceStorage = /* @__PURE__ */ new Map();
+	const sortingParameterEnumRef = lazy(() => schemaBuilder.enumType("SortingParameter", { values: ["asc", "desc"] }));
+	const orderArgImplementer = ({ table, refName, dbName }) => {
+		const tableSchema = tableHelper({
+			db,
+			table: dbName ?? table
+		});
+		const inputTypeName = refName ?? makeDefaultName$1(tableSchema.tsName);
+		let ret = referenceStorage.get(inputTypeName);
+		if (ret) return ret;
+		const implement = () => {
+			return schemaBuilder.inputType(inputTypeName, { fields: (t) => {
+				const fields = Object.entries(tableSchema.columns).reduce((acc, [key]) => {
+					acc[key] = t.field({
+						type: sortingParameterEnumRef(),
+						required: false
+					});
+					return acc;
+				}, {});
+				const relations = Object.entries(tableSchema.relations ?? {}).reduce((acc, [key, value]) => {
+					const referenceModel = orderArgImplementer({ dbName: tableHelper({
+						db,
+						table: value.targetTable
+					}).dbName });
+					acc[key] = t.field({
+						type: referenceModel,
+						required: false
+					});
+					return acc;
+				}, {});
+				return {
+					...fields,
+					...relations
+				};
+			} });
+		};
+		ret = implement();
+		referenceStorage.set(inputTypeName, ret);
+		return ret;
+	};
+	return orderArgImplementer;
+};
+
+//#endregion
+//#region lib/enum.ts
+/**
+* Checks if a schema type is an enum
+*/
+function isEnumSchema(schemaType) {
+	return schemaType instanceof PgEnumColumn;
+}
+const createEnumImplementer = ({ db, schemaBuilder }) => {
+	const referenceStorage = /* @__PURE__ */ new Map();
+	const enumImplementer = ({ tsName, enumColumn, refName }) => {
+		let enumSchemaName;
+		let enumValues;
+		if (tsName) {
+			const schemaEnum = db._.schema[tsName];
+			enumSchemaName = tsName.toString();
+			const enumCol = Object.values(db._.schema).filter((s) => typeof s === "object").map((s) => Object.values(s.columns)).flat(2).find((s) => s.config?.enum === schemaEnum);
+			if (!enumCol) throw new RumbleError(`Could not find applied enum column for ${tsName.toString()}.
+Please ensure that you use the enum at least once as a column of a table!`);
+			enumValues = enumCol.enumValues;
+		} else if (enumColumn) {
+			enumSchemaName = enumColumn.config.name;
+			enumValues = enumColumn.enumValues;
+		}
+		if (!enumSchemaName || !enumValues) throw new RumbleError("Could not determine enum structure!");
+		const graphqlImplementationName = refName ?? `${capitalize(toCamelCase(enumSchemaName))}Enum`;
+		let ret = referenceStorage.get(graphqlImplementationName);
+		if (ret) return ret;
+		const implement = () => schemaBuilder.enumType(graphqlImplementationName, { values: enumValues });
+		ret = implement();
+		referenceStorage.set(graphqlImplementationName, ret);
+		return ret;
+	};
+	return enumImplementer;
+};
+
+//#endregion
+//#region lib/helpers/sqlTypes/mapSQLTypeToTSType.ts
+function mapSQLTypeToGraphQLType({ sqlType, fieldName }) {
+	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";
+	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 (ret !== void 0) return ret;
+	throw UnknownTypeRumbleError(sqlType, "SQL to GQL");
+}
+
+//#endregion
+//#region lib/args/whereArg.ts
+const makeDefaultName = (dbName) => `${capitalize(toCamelCase(dbName.toString()))}WhereInputArgument`;
+const createWhereArgImplementer = ({ db, schemaBuilder, enumImplementer }) => {
+	const referenceStorage = /* @__PURE__ */ new Map();
+	const whereArgImplementer = ({ table, refName, dbName }) => {
+		const tableSchema = tableHelper({
+			db,
+			table: dbName ?? table
+		});
+		const inputTypeName = refName ?? makeDefaultName(tableSchema.tsName);
+		let ret = referenceStorage.get(inputTypeName);
+		if (ret) return ret;
+		const implement = () => {
+			return schemaBuilder.inputType(inputTypeName, { fields: (t) => {
+				const mapSQLTypeStringToInputPothosType = (sqlType, fieldName) => {
+					const gqlType = mapSQLTypeToGraphQLType({
+						sqlType,
+						fieldName
+					});
+					switch (gqlType) {
+						case "Int": return t.field({ type: "IntWhereInputArgument" });
+						case "String": return t.field({ type: "StringWhereInputArgument" });
+						case "Boolean": return t.boolean({ required: false });
+						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.id({ required: false });
+						case "JSON": return t.field({
+							type: "JSON",
+							required: false
+						});
+						default: throw new RumbleError(`Unsupported argument type ${gqlType} for column ${sqlType}`);
+					}
+				};
+				const fields = Object.entries(tableSchema.columns).reduce((acc, [key, value]) => {
+					if (isEnumSchema(value)) {
+						const enumImpl = enumImplementer({ enumColumn: value });
+						acc[key] = t.field({
+							type: enumImpl,
+							required: false
+						});
+					} else acc[key] = mapSQLTypeStringToInputPothosType(value.getSQLType(), key);
+					return acc;
+				}, {});
+				const relations = Object.entries(tableSchema.relations ?? {}).reduce((acc, [key, value]) => {
+					const referenceModel = whereArgImplementer({ dbName: tableHelper({
+						db,
+						table: value.targetTable
+					}).dbName });
+					acc[key] = t.field({
+						type: referenceModel,
+						required: false
+					});
+					return acc;
+				}, {});
+				return {
+					...fields,
+					...relations
+				};
+			} });
+		};
+		ret = implement();
+		referenceStorage.set(inputTypeName, ret);
+		return ret;
+	};
+	return whereArgImplementer;
+};
+
+//#endregion
+//#region lib/client/client.ts
+const clientCreatorImplementer = ({ builtSchema }) => {
+	if (process.env.NODE_ENV !== "development") console.warn("Running rumble client generation in non development mode. Are you sure this is correct?");
+	const clientCreator = async ({ apiUrl, outputPath, rumbleImportPath, useExternalUrqlClient }) => {
+		await generateFromSchema({
+			schema: builtSchema(),
+			outputPath,
+			rumbleImportPath,
+			apiUrl,
+			useExternalUrqlClient
+		});
+	};
+	return clientCreator;
+};
+
+//#endregion
+//#region lib/context.ts
+const createContextFunction = ({ context: makeUserContext, abilityBuilder }) => {
+	const builtAbilityBuilder = lazy(() => abilityBuilder._.build());
+	return async (req) => {
+		const userContext = makeUserContext ? await makeUserContext(req) : {};
+		return {
+			...userContext,
+			abilities: builtAbilityBuilder()(userContext)
+		};
+	};
+};
+
+//#endregion
+//#region lib/helpers/sofaOpenAPIWebhookDocs.ts
+const sofaOpenAPIWebhookDocs = {
+	paths: {
+		"/webhook": { post: {
+			operationId: "webhook_create",
+			description: "Creates a webhook subscription.",
+			tags: [],
+			parameters: [],
+			requestBody: { content: { "application/json": { schema: { $ref: "#/components/schemas/WebhookCreateBody" } } } },
+			responses: { "200": {
+				description: "",
+				content: { "application/json": { schema: { $ref: "#/components/schemas/WebhookDetailResponse" } } }
+			} }
+		} },
+		"/webhook/{id}": {
+			post: {
+				operationId: "webhook_update",
+				description: "Updates a webhook subscription.",
+				parameters: [{
+					name: "id",
+					in: "path",
+					description: "The ID of the webhook to update",
+					required: true,
+					schema: { type: "string" }
+				}],
+				requestBody: { content: { "application/json": { schema: { $ref: "#/components/schemas/WebhookCreateBody" } } } },
+				responses: { "200": {
+					description: "",
+					content: { "application/json": { schema: { $ref: "#/components/schemas/WebhookDetailResponse" } } }
+				} }
+			},
+			delete: {
+				operationId: "webhook_delete",
+				description: "Removes a webhook subscription.",
+				tags: [],
+				parameters: [{
+					name: "id",
+					in: "path",
+					description: "The ID of the webhook to delete",
+					required: true,
+					schema: { type: "string" }
+				}],
+				responses: { "200": {
+					description: "",
+					content: { "application/json": { schema: { $ref: "#/components/schemas/WebhookDetailResponse" } } }
+				} }
+			}
+		}
+	},
+	components: { schemas: {
+		WebhookCreateBody: {
+			type: "object",
+			properties: {
+				subscription: {
+					description: "The subscription to subscribe to. In many cases, these match the available query IDs without the '_query' suffix. E.g., 'users_query' -> 'users'. See the graphql schema for more details on what subscriptions are available.",
+					type: "string"
+				},
+				variables: {
+					description: "The variables to pass to the subscription.",
+					type: "object"
+				},
+				url: {
+					description: "The URL to send the webhook to.",
+					type: "string"
+				}
+			}
+		},
+		WebhookDetailResponse: {
+			type: "object",
+			properties: { id: {
+				description: "The ID of the webhook. Can be used as reference in update or delete calls.",
+				type: "string"
+			} }
+		},
+		DateTime: {
+			type: "string",
+			format: "date-time"
+		},
+		Date: {
+			type: "string",
+			format: "date"
+		}
+	} }
+};
+
+//#endregion
+//#region lib/helpers/sqlTypes/mapDrizzleTypeToGraphQlType.ts
+function buildPothosResponseTypeFromGraphQLType({ builder, sqlType, fieldName, nullable }) {
+	const gqlType = mapSQLTypeToGraphQLType({
+		sqlType,
+		fieldName
+	});
+	switch (gqlType) {
+		case "Int": return builder.exposeInt(fieldName, { nullable });
+		case "String": return builder.exposeString(fieldName, { nullable });
+		case "Boolean": return builder.exposeBoolean(fieldName, { nullable });
+		case "Date": return builder.field({
+			type: "Date",
+			resolve: (element) => element[fieldName],
+			nullable
+		});
+		case "DateTime": return builder.field({
+			type: "DateTime",
+			resolve: (element) => element[fieldName],
+			nullable
+		});
+		case "Float": return builder.exposeFloat(fieldName, { nullable });
+		case "ID": return builder.exposeID(fieldName, { nullable });
+		case "JSON": return builder.field({
+			type: "JSON",
+			resolve: (element) => element[fieldName],
+			nullable
+		});
+		default: throw new RumbleError(`Unsupported object type ${gqlType} for column ${fieldName}`);
+	}
+}
+
+//#endregion
+//#region lib/helpers/determineDialectFromSchema.ts
+function determineDBDialectFromSchema(schema) {
+	const found = /* @__PURE__ */ new Set();
+	for (const table of Object.values(schema)) {
+		if (typeof table !== "object") continue;
+		if (table instanceof PgTable) found.add("postgres");
+		else if (table instanceof MySqlTable) found.add("mysql");
+		else if (table instanceof SQLiteTable) found.add("sqlite");
+	}
+	const dialects = Array.from(found);
+	if (dialects.length === 1) return dialects[0];
+	if (dialects.length === 0) throw new Error("No tables found in schema, could not determine dialect");
+	throw new Error(`Multiple dialects found in schema: ${dialects.join(", ")}`);
+}
+function isPostgresDB(db) {
+	return determineDBDialectFromSchema(db._.schema) === "postgres";
+}
+
+//#endregion
+//#region lib/search.ts
+async function initSearchIfApplicable(db) {
+	if (!isPostgresDB(db)) {
+		console.info("Database dialect is not compatible with search, skipping search initialization.");
+		return;
+	}
+	await db.execute(sql`CREATE EXTENSION IF NOT EXISTS pg_trgm;`);
+}
+/**
+* Performs adjustments to the query args to issue a full text search in case the
+* respective feature is enabled and a search term was provided.
+*/
+function adjustQueryArgsForSearch({ search, args, tableSchema, abilities }) {
+	if (search?.enabled && args.search && args.search.length > 0) {
+		const originalOrderBy = cloneDeep(args.orderBy);
+		args.orderBy = (table) => {
+			const argsOrderBySQL = sql.join(Object.entries(originalOrderBy ?? {}).map(([key, value]) => {
+				if (value === "asc") return sql`${table[key]} ASC`;
+				else if (value === "desc") return sql`${table[key]} DESC`;
+				else throw new Error(`Invalid value ${value} for orderBy`);
+			}), sql.raw(", "));
+			const columnsToSearch = abilities.query.many.columns ? Object.entries(tableSchema.columns).filter(([key]) => abilities.query.many.columns[key]) : Object.entries(tableSchema.columns);
+			const searchSQL = sql`GREATEST(${sql.join(columnsToSearch.map(([key]) => {
+				return sql`similarity(${table[key]}::TEXT, ${args.search})`;
+			}), sql.raw(", "))}) DESC`;
+			return originalOrderBy ? sql.join([argsOrderBySQL, searchSQL], sql.raw(", ")) : searchSQL;
+		};
+		args.where = { AND: [cloneDeep(args.where) ?? {}, { RAW: (table) => {
+			return sql`GREATEST(${sql.join(Object.entries(tableSchema.columns).map(([key]) => {
+				return sql`similarity(${table[key]}::TEXT, ${args.search})`;
+			}), sql.raw(", "))}) > ${search.threshold ?? .1}`;
+		} }] };
+	}
+}
+
+//#endregion
+//#region lib/object.ts
+const isProbablyAConfigObject = (t) => {
+	if (typeof t !== "object") return false;
+	if (Object.keys(t).some((k) => [
+		"args",
+		"nullable",
+		"query",
+		"subscribe",
+		"description",
+		"type",
+		"resolve"
+	].find((e) => e === k))) return true;
+	return false;
+};
+const createObjectImplementer = ({ db, search, 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!`);
+		const primaryKey = Object.values(tableSchema.primaryKey)[0];
+		const { registerOnInstance } = makePubSubInstance({ table });
+		return schemaBuilder.drizzleObject(table, {
+			name: refName ?? capitalize(table.toString()),
+			subscribe: (subscriptions, element, _context) => {
+				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!`);
+					return;
+				}
+				registerOnInstance({
+					instance: subscriptions,
+					action: "updated",
+					primaryKeyValue
+				});
+			},
+			applyFilters: abilityBuilder?._.registeredFilters({
+				table,
+				action: readAction
+			}),
+			fields: (t) => {
+				const columns = tableSchema.columns;
+				const configMap = /* @__PURE__ */ new Map();
+				const userAdjustments = adjust?.(new Proxy(t, { get: (target, prop) => {
+					if (typeof target[prop] !== "function" || prop === "arg" || prop === "builder" || prop === "graphqlKind" || prop === "kind" || prop === "listRef" || prop === "table" || prop === "typename" || prop === "variant" || prop.toString().startsWith("boolean") || prop.toString().startsWith("float") || prop.toString().startsWith("id") || prop.toString().startsWith("int") || prop.toString().startsWith("string") || prop.toString().startsWith("expose")) return target[prop];
+					return (...params) => {
+						const ref = target[prop](...params);
+						const configObject = params.find(isProbablyAConfigObject);
+						if (!configObject) throw new RumbleError("Expected config object to be passed to adjust field");
+						configMap.set(ref, {
+							params,
+							creatorFunction: target[prop],
+							configObject
+						});
+						return ref;
+					};
+				} })) ?? {};
+				const fields = Object.entries(columns).reduce((acc, [key, value]) => {
+					if (userAdjustments[key]) {
+						const { params, creatorFunction, configObject } = configMap.get(userAdjustments[key]);
+						if (typeof configObject.nullable !== "boolean") configObject.nullable = !value.notNull;
+						userAdjustments[key] = creatorFunction.bind(t)(...params);
+						return acc;
+					}
+					if (isEnumSchema(value)) {
+						const enumImpl = enumImplementer({ enumColumn: value });
+						acc[key] = t.field({
+							type: enumImpl,
+							resolve: (element) => element[key],
+							nullable: !value.notNull
+						});
+					} else acc[key] = buildPothosResponseTypeFromGraphQLType({
+						builder: t,
+						sqlType: value.getSQLType(),
+						fieldName: key,
+						nullable: !value.notNull
+					});
+					return acc;
+				}, {});
+				const relations = Object.entries(tableSchema.relations ?? {}).reduce((acc, [key, value]) => {
+					const relationSchema = tableHelper({
+						db,
+						table: value.targetTable
+					});
+					const WhereArg = whereArgImplementer({ dbName: relationSchema.dbName });
+					const OrderArg = orderArgImplementer({ dbName: relationSchema.dbName });
+					const relationTablePubSub = makePubSubInstance({ table: relationSchema.tsName });
+					let nullable = false;
+					let isMany = true;
+					let filterSpecifier = "many";
+					if (value instanceof One) {
+						isMany = false;
+						nullable = value.optional;
+						filterSpecifier = "single";
+					}
+					const subscribe = (subscriptions, _element) => {
+						relationTablePubSub.registerOnInstance({
+							instance: subscriptions,
+							action: "created"
+						});
+						relationTablePubSub.registerOnInstance({
+							instance: subscriptions,
+							action: "removed"
+						});
+					};
+					if (userAdjustments[key]) {
+						const { params, creatorFunction, configObject } = configMap.get(userAdjustments[key]);
+						if (typeof configObject.nullable !== "boolean") configObject.nullable = nullable;
+						if (typeof configObject.subscribe !== "function") configObject.subscribe = subscribe;
+						userAdjustments[key] = creatorFunction.bind(t)(...params);
+						return acc;
+					}
+					const args = {
+						where: t.arg({
+							type: WhereArg,
+							required: false
+						}),
+						orderBy: t.arg({
+							type: OrderArg,
+							required: false
+						}),
+						...isMany ? {
+							offset: t.arg.int({ required: false }),
+							limit: t.arg.int({ required: false })
+						} : {},
+						search: t.arg.string({ required: false })
+					};
+					if (!search?.enabled || !isMany) delete args.search;
+					acc[key] = t.relation(key, {
+						args,
+						subscribe,
+						nullable,
+						description: `Get the ${pluralize.plural(relationSchema.tsName)} related to this ${pluralize.singular(tableSchema.tsName)}`,
+						query: (args$1, ctx) => {
+							args$1 = JSON.parse(JSON.stringify(args$1));
+							if (isMany) adjustQueryArgsForSearch({
+								search,
+								args: args$1,
+								tableSchema: relationSchema,
+								abilities: ctx.abilities[relationSchema.tsName].filter(readAction)
+							});
+							const filter = ctx.abilities[relationSchema.tsName].filter(readAction).merge({
+								where: args$1.where,
+								limit: args$1.limit
+							}).query[filterSpecifier];
+							if (args$1.offset) filter.offset = args$1.offset;
+							if (args$1.orderBy) filter.orderBy = args$1.orderBy;
+							return filter;
+						}
+					});
+					return acc;
+				}, {});
+				return {
+					...fields,
+					...relations,
+					...userAdjustments
+				};
+			}
+		});
+	};
+};
+
+//#endregion
+//#region lib/pubsub.ts
+const SUBSCRIPTION_NOTIFIER_RUMBLE_PREFIX = "RUMBLE_SUBSCRIPTION_NOTIFICATION";
+const SUBSCRIPTION_NOTIFIER_REMOVED = "REMOVED";
+const SUBSCRIPTION_NOTIFIER_UPDATED = "UPDATED";
+const SUBSCRIPTION_NOTIFIER_CREATED = "CREATED";
+const createPubSubInstance = ({ subscriptions }) => {
+	const pubsub = subscriptions ? createPubSub(...subscriptions) : createPubSub();
+	const makePubSubInstance = ({ table }) => {
+		function makePubSubKey({ action, tableName, primaryKeyValue }) {
+			let actionKey;
+			switch (action) {
+				case "created":
+					actionKey = SUBSCRIPTION_NOTIFIER_CREATED;
+					break;
+				case "removed":
+					actionKey = SUBSCRIPTION_NOTIFIER_REMOVED;
+					break;
+				case "updated":
+					actionKey = SUBSCRIPTION_NOTIFIER_UPDATED;
+					break;
+				default: throw new Error(`Unknown action: ${action}`);
+			}
+			return `${SUBSCRIPTION_NOTIFIER_RUMBLE_PREFIX}/${tableName}${primaryKeyValue ? `/${primaryKeyValue}` : ""}/${actionKey}`;
+		}
+		return {
+			registerOnInstance({ instance, action, primaryKeyValue }) {
+				const key = makePubSubKey({
+					tableName: table.toString(),
+					action,
+					primaryKeyValue
+				});
+				instance.register(key);
+			},
+			created() {
+				const key = makePubSubKey({
+					tableName: table.toString(),
+					action: "created"
+				});
+				return pubsub.publish(key);
+			},
+			removed() {
+				const key = makePubSubKey({
+					tableName: table.toString(),
+					action: "removed"
+				});
+				return pubsub.publish(key);
+			},
+			updated(primaryKeyValue) {
+				const keys = (Array.isArray(primaryKeyValue) ? primaryKeyValue : [primaryKeyValue]).map((primaryKeyValue$1) => makePubSubKey({
+					tableName: table.toString(),
+					action: "updated",
+					primaryKeyValue: primaryKeyValue$1
+				}));
+				const uniqueKeys = Array.from(new Set(keys));
+				for (const key of uniqueKeys) pubsub.publish(key);
+			}
+		};
+	};
+	return {
+		pubsub,
+		makePubSubInstance
+	};
+};
+
+//#endregion
+//#region lib/query.ts
+const createQueryImplementer = ({ db, schemaBuilder, search, whereArgImplementer, orderArgImplementer, makePubSubInstance }) => {
+	return ({ table, readAction = "read", listAction = "read" }) => {
+		const WhereArg = whereArgImplementer({ table });
+		const OrderArg = orderArgImplementer({ table });
+		const tableSchema = tableHelper({
+			db,
+			table
+		});
+		const primaryKeyField = Object.values(tableSchema.primaryKey)[0];
+		const { registerOnInstance } = makePubSubInstance({ table });
+		return schemaBuilder.queryFields((t) => {
+			const manyArgs = {
+				where: t.arg({
+					type: WhereArg,
+					required: false
+				}),
+				orderBy: t.arg({
+					type: OrderArg,
+					required: false
+				}),
+				limit: t.arg.int({ required: false }),
+				offset: t.arg.int({ required: false }),
+				search: t.arg.string({ required: false })
+			};
+			if (!search?.enabled) delete manyArgs.search;
+			return {
+				[pluralize.plural(table.toString())]: t.drizzleField({
+					type: [table],
+					nullable: false,
+					smartSubscription: true,
+					description: `List all ${pluralize.plural(table.toString())}`,
+					subscribe: (subscriptions, _root, _args, _ctx, _info) => {
+						registerOnInstance({
+							instance: subscriptions,
+							action: "created"
+						});
+						registerOnInstance({
+							instance: subscriptions,
+							action: "removed"
+						});
+					},
+					args: manyArgs,
+					resolve: (query, _root, args, ctx, _info) => {
+						Object.setPrototypeOf(args, Object.prototype);
+						adjustQueryArgsForSearch({
+							search,
+							args,
+							tableSchema,
+							abilities: ctx.abilities[table].filter(listAction)
+						});
+						const mappedArgs = mapNullFieldsToUndefined(args);
+						const filter = ctx.abilities[table].filter(listAction).merge(mappedArgs).query.many;
+						if (mappedArgs.offset) filter.offset = mappedArgs.offset;
+						if (mappedArgs.orderBy) filter.orderBy = mappedArgs.orderBy;
+						const queryInstance = query(filter);
+						if (filter.columns) queryInstance.columns = filter.columns;
+						return db.query[table].findMany(queryInstance);
+					}
+				}),
+				[pluralize.singular(table.toString())]: t.drizzleField({
+					type: table,
+					nullable: false,
+					smartSubscription: true,
+					description: `Get a single ${pluralize.singular(table.toString())} by ID`,
+					args: { id: t.arg.id({ required: true }) },
+					resolve: (query, _root, args, ctx, _info) => {
+						Object.setPrototypeOf(args, Object.prototype);
+						const filter = ctx.abilities[table].filter(readAction).merge({ where: { [primaryKeyField.name]: args.id } }).query.single;
+						const q = query(filter);
+						if (filter.columns) q.columns = filter.columns;
+						return db.query[table].findFirst(q).then(assertFindFirstExists);
+					}
+				})
+			};
+		});
+	};
+};
+
+//#endregion
+//#region lib/args/whereArgsImplementer.ts
+function implementDefaultWhereInputArgs(schemaBuilder) {
+	const IntWhereInputArgument = schemaBuilder.inputRef("IntWhereInputArgument").implement({ fields: (t) => ({
+		eq: t.int(),
+		ne: t.int(),
+		gt: t.int(),
+		gte: t.int(),
+		lt: t.int(),
+		lte: t.int(),
+		in: t.intList(),
+		notIn: t.intList(),
+		like: t.string(),
+		ilike: t.string(),
+		notLike: t.string(),
+		notIlike: t.string(),
+		isNull: t.boolean(),
+		isNotNull: t.boolean(),
+		arrayOverlaps: t.intList(),
+		arrayContained: t.intList(),
+		arrayContains: t.intList(),
+		AND: t.field({ type: [IntWhereInputArgument] }),
+		OR: t.field({ type: [IntWhereInputArgument] }),
+		NOT: t.field({ type: IntWhereInputArgument })
+	}) });
+	const FloatWhereInputArgument = schemaBuilder.inputRef("FloatWhereInputArgument").implement({ fields: (t) => ({
+		eq: t.float(),
+		ne: t.float(),
+		gt: t.float(),
+		gte: t.float(),
+		lt: t.float(),
+		lte: t.float(),
+		in: t.floatList(),
+		notIn: t.floatList(),
+		like: t.string(),
+		ilike: t.string(),
+		notLike: t.string(),
+		notIlike: t.string(),
+		isNull: t.boolean(),
+		isNotNull: t.boolean(),
+		arrayOverlaps: t.floatList(),
+		arrayContained: t.floatList(),
+		arrayContains: t.floatList(),
+		AND: t.field({ type: [FloatWhereInputArgument] }),
+		OR: t.field({ type: [FloatWhereInputArgument] }),
+		NOT: t.field({ type: FloatWhereInputArgument })
+	}) });
+	const StringWhereInputArgument = schemaBuilder.inputRef("StringWhereInputArgument").implement({ fields: (t) => ({
+		eq: t.string(),
+		ne: t.string(),
+		gt: t.string(),
+		gte: t.string(),
+		lt: t.string(),
+		lte: t.string(),
+		in: t.stringList(),
+		notIn: t.stringList(),
+		like: t.string(),
+		ilike: t.string(),
+		notLike: t.string(),
+		notIlike: t.string(),
+		isNull: t.boolean(),
+		isNotNull: t.boolean(),
+		arrayOverlaps: t.stringList(),
+		arrayContained: t.stringList(),
+		arrayContains: t.stringList(),
+		AND: t.field({ type: [StringWhereInputArgument] }),
+		OR: t.field({ type: [StringWhereInputArgument] }),
+		NOT: t.field({ type: StringWhereInputArgument })
+	}) });
+	const DateWhereInputArgument = schemaBuilder.inputRef("DateWhereInputArgument").implement({ fields: (t) => ({
+		eq: t.field({ type: "Date" }),
+		ne: t.field({ type: "Date" }),
+		gt: t.field({ type: "Date" }),
+		gte: t.field({ type: "Date" }),
+		lt: t.field({ type: "Date" }),
+		lte: t.field({ type: "Date" }),
+		in: t.field({ type: ["Date"] }),
+		notIn: t.field({ type: ["Date"] }),
+		like: t.string(),
+		ilike: t.string(),
+		notLike: t.string(),
+		notIlike: t.string(),
+		isNull: t.boolean(),
+		isNotNull: t.boolean(),
+		arrayOverlaps: t.field({ type: ["Date"] }),
+		arrayContained: t.field({ type: ["Date"] }),
+		arrayContains: t.field({ type: ["Date"] }),
+		AND: t.field({ type: [DateWhereInputArgument] }),
+		OR: t.field({ type: [DateWhereInputArgument] }),
+		NOT: t.field({ type: DateWhereInputArgument })
+	}) });
+}
+
+//#endregion
+//#region lib/runtimeFiltersPlugin/filterTypes.ts
+const pluginName = "RuntimeFiltersPlugin";
+
+//#endregion
+//#region lib/helpers/applyFilters.ts
+/**
+* A helper to apply a list of filters to a given list of entities.
+* 
+* @example
+* 
+* ```ts
+* const filtered = await applyFilters({
+filters: abilityBuilder.registeredFilters.posts.update,
+entities: entitiesToFilter,
+context: ctx,
+});
+* ```
+*/
+const applyFilters = async ({ filters, entities, context }) => {
+	return Array.from((await Promise.all(filters.map((f) => f({
+		context,
+		entities
+	})))).reduce((acc, val) => {
+		for (const element of val) acc.add(element);
+		return acc;
+	}, /* @__PURE__ */ new Set()));
+};
+
+//#endregion
+//#region lib/runtimeFiltersPlugin/runtimeFiltersPlugin.ts
+const applyFiltersKey = "applyFilters";
+var RuntimeFiltersPlugin = class extends BasePlugin {
+	wrapResolve(resolver, fieldConfig) {
+		return async (parent, args, context, info) => {
+			let filters;
+			const fieldType = fieldConfig?.type;
+			if (fieldType.kind === "List") filters = fieldType.type?.ref.currentConfig.pothosOptions[applyFiltersKey];
+			else if (fieldType.kind === "Object") filters = fieldType.ref.currentConfig.pothosOptions[applyFiltersKey];
+			if (!filters || !Array.isArray(filters) || filters.length === 0) return resolver(parent, args, context, info);
+			const resolved = await resolver(parent, args, context, info);
+			const allResolvedValues = Array.isArray(resolved) ? resolved : [resolved];
+			const allowed = await applyFilters({
+				filters: Array.isArray(filters) ? filters : [filters],
+				entities: allResolvedValues,
+				context
+			});
+			if (Array.isArray(resolved)) return allowed;
+			return allowed[0] ?? null;
+		};
+	}
+};
+let registered = false;
+function registerRuntimeFiltersPlugin() {
+	if (!registered) {
+		SchemaBuilder.registerPlugin(pluginName, RuntimeFiltersPlugin);
+		registered = true;
+	}
+}
+
+//#endregion
+//#region lib/schemaBuilder.ts
+const createSchemaBuilder = ({ db, disableDefaultObjects, pubsub, pothosConfig }) => {
+	registerRuntimeFiltersPlugin();
+	const schemaBuilder = new SchemaBuilder({
+		...pothosConfig,
+		plugins: [
+			pluginName,
+			DrizzlePlugin,
+			SmartSubscriptionsPlugin,
+			...pothosConfig?.plugins ?? []
+		],
+		drizzle: {
+			client: db,
+			relations: db._.relations,
+			getTableConfig(table) {
+				return {
+					columns: Object.values(table[Symbol.for("drizzle:Columns")]),
+					primaryKeys: Object.values(table[Symbol.for("drizzle:Columns")]).filter((v) => v.primary)
+				};
+			}
+		},
+		smartSubscriptions: { ...subscribeOptionsFromIterator((name, _context) => {
+			return pubsub.subscribe(name);
+		}) }
+	});
+	schemaBuilder.addScalarType("JSON", JSONResolver);
+	schemaBuilder.addScalarType("Date", DateResolver);
+	schemaBuilder.addScalarType("DateTime", DateTimeISOResolver);
+	implementDefaultWhereInputArgs(schemaBuilder);
+	if (!disableDefaultObjects?.query) schemaBuilder.queryType({});
+	if (!disableDefaultObjects?.subscription) schemaBuilder.subscriptionType({});
+	if (!disableDefaultObjects?.mutation) schemaBuilder.mutationType({});
+	return { schemaBuilder };
+};
+
+//#endregion
+//#region lib/rumble.ts
+const rumble = (rumbleInput) => {
+	if (!rumbleInput.db._.schema) throw new RumbleError(`
+rumble could not find any schema in the provided drizzle instance.
+Make sure you import the schema and pass it to the drizzle instance:
+
+export const db = drizzle(
+  "postgres://postgres:postgres@localhost:5432/postgres",
+  {
+    relations,
+    schema,    // <--- add this line
+  },
+);
+
+`);
+	if (!rumbleInput.db._.relations) throw new RumbleError(`
+rumble could not find any relations in the provided drizzle instance.
+Make sure you import the relations and pass them to the drizzle instance:
+
+export const db = drizzle(
+  "postgres://postgres:postgres@localhost:5432/postgres",
+  {
+    relations, // <--- add this line
+    schema,   
+  },
+);
+
+`);
+	if (!rumbleInput.actions) rumbleInput.actions = [
+		"read",
+		"update",
+		"delete"
+	];
+	if (rumbleInput.defaultLimit === void 0) rumbleInput.defaultLimit = 100;
+	if (rumbleInput.search?.enabled) initSearchIfApplicable(rumbleInput.db);
+	const abilityBuilder = createAbilityBuilder(rumbleInput);
+	const context = createContextFunction({
+		...rumbleInput,
+		abilityBuilder
+	});
+	const { makePubSubInstance, pubsub } = createPubSubInstance({ ...rumbleInput });
+	const { schemaBuilder } = createSchemaBuilder({
+		...rumbleInput,
+		pubsub
+	});
+	const enum_ = createEnumImplementer({
+		...rumbleInput,
+		schemaBuilder
+	});
+	const whereArg = createWhereArgImplementer({
+		...rumbleInput,
+		schemaBuilder,
+		enumImplementer: enum_
+	});
+	const orderArg = createOrderArgImplementer({
+		...rumbleInput,
+		schemaBuilder
+	});
+	const object = createObjectImplementer({
+		...rumbleInput,
+		schemaBuilder,
+		makePubSubInstance,
+		whereArgImplementer: whereArg,
+		orderArgImplementer: orderArg,
+		enumImplementer: enum_,
+		abilityBuilder
+	});
+	const query = createQueryImplementer({
+		...rumbleInput,
+		schemaBuilder,
+		whereArgImplementer: whereArg,
+		orderArgImplementer: orderArg,
+		makePubSubInstance
+	});
+	const builtSchema = lazy(() => schemaBuilder.toSchema());
+	const createYoga$1 = (args) => {
+		const enableApiDocs = args?.enableApiDocs ?? process?.env?.NODE_ENV === "development";
+		return createYoga({
+			...args,
+			graphiql: enableApiDocs,
+			plugins: [...args?.plugins ?? [], ...enableApiDocs ? [] : [useDisableIntrospection(), EnvelopArmorPlugin()]].filter(Boolean),
+			schema: builtSchema(),
+			context
+		});
+	};
+	const createSofa = (args) => {
+		if (args.openAPI) merge(args.openAPI, sofaOpenAPIWebhookDocs);
+		return useSofa({
+			...args,
+			schema: builtSchema(),
+			context
+		});
+	};
+	return {
+		abilityBuilder,
+		schemaBuilder,
+		createYoga: createYoga$1,
+		createSofa,
+		object,
+		whereArg,
+		orderArg,
+		query,
+		pubsub: makePubSubInstance,
+		enum_,
+		clientCreator: clientCreatorImplementer({
+			...rumbleInput,
+			builtSchema
+		})
+	};
+};
+
+//#endregion
+export { RumbleError, RumbleErrorSafe, assertFindFirstExists, assertFirstEntryExists, generateFromSchema, makeLiveQuery, makeMutation, makeQuery, makeSubscription, mapNullFieldsToUndefined, rumble };
+//# sourceMappingURL=index.js.map