✨ feat: default arg implementation

Author: m1212e

README.md

@@ -94,6 +94,48 @@ const UserRef = implementDefaultObject({
 });
 ```
 
+#### Automatic arg implementation
+rumble also supports automatically implementing basic filtering args. Those currently only allow for equality filtering for each field. E.g. the user can pass an email or an id and retrieve only results matching these for equality. Implementation works like this
+```ts
+const {
+  // the input arg type, here we rename it to UserWhere
+  inputType: UserWhere,
+  // since drizzle wants proper instantiated filter clauses with `eq` calls and references to each field we need a transformer function which converts the object received from gql to a drizzle filter
+  transformArgumentToQueryCondition: transformUserWhere,
+} = implementWhereArg({
+  // for which table to implement this
+  tableName: "users",
+});
+```
+usage of the above argument type may look like this
+```ts
+schemaBuilder.queryFields((t) => {
+  return {
+    findManyUsers: t.drizzleField({
+      type: [UserRef],
+      args: {
+        // here we set our default type as type for the where argument
+        where: t.arg({ type: UserWhere }),
+      },
+      resolve: (query, root, args, ctx, info) => {
+        return db.query.users.findMany(
+          query(
+            ctx.abilities.users.filter("read", 
+            // this additional object offers temporarily injecting additional filters to our existing ability filters
+            {
+              // the inject field allows for temp, this time only filters to be added to our ability filters. They will only be applied for this specific call.
+              inject: { 
+                // where conditions which are injected will be applied with an AND rather than an OR so the injected filter will further restrict the existing restrictions rather than expanding them
+                where: transformUserWhere(args.where) },
+            })
+          )
+        );
+      },
+    }),
+  };
+});
+```
+
 ### Defining queries and mutations
 Now we can define some things you can do. Again we use pothos for that. So please refer to [the docs](https://pothos-graphql.dev/docs/plugins/drizzle) if something is unclear.
 ```ts

bun.lockb

@@ -13,7 +13,13 @@ export const db = drizzle(
 	{ schema },
 );
 
-const { abilityBuilder, schemaBuilder, yoga, implementDefaultObject } = rumble({
+const {
+	abilityBuilder,
+	schemaBuilder,
+	yoga,
+	implementDefaultObject,
+	implementWhereArg,
+} = rumble({
 	db,
 	context(request) {
 		return {
@@ -65,15 +71,28 @@ const PostRef = schemaBuilder.drizzleObject("posts", {
 //   DEFINE ROOT QUERIES AND MUTATOINS
 //
 
+const {
+	inputType: UserWhere,
+	transformArgumentToQueryCondition: transformUserWhere,
+} = implementWhereArg({
+	tableName: "users",
+});
+
 schemaBuilder.queryFields((t) => {
 	return {
 		findManyUsers: t.drizzleField({
 			type: [UserRef],
+			args: {
+				where: t.arg({ type: UserWhere }),
+			},
 			resolve: (query, root, args, ctx, info) => {
-				return db.query.users.findMany({
-					...query,
-					...ctx.abilities.users.filter("read"),
-				});
+				return db.query.users.findMany(
+					query(
+						ctx.abilities.users.filter("read", {
+							inject: { where: transformUserWhere(args.where) },
+						}),
+					),
+				);
 			},
 		}),
 	};
@@ -84,10 +103,9 @@ schemaBuilder.queryFields((t) => {
 		findManyPosts: t.drizzleField({
 			type: [PostRef],
 			resolve: (query, root, args, ctx, info) => {
-				return db.query.posts.findMany({
-					...query,
-					...ctx.abilities.posts.filter("read"),
-				});
+				return db.query.posts.findMany(
+					query(ctx.abilities.posts.filter("read")),
+				);
 			},
 		}),
 	};
@@ -100,10 +118,11 @@ schemaBuilder.queryFields((t) => {
 			resolve: (query, root, args, ctx, info) => {
 				return (
 					db.query.users
-						.findFirst({
-							...query,
-							where: ctx.abilities.users.filter("read").where,
-						})
+						.findFirst(
+							query({
+								where: ctx.abilities.users.filter("read").where,
+							}),
+						)
 						// note that we need to manually raise an error if the value is not found
 						.then(assertFindFirstExists)
 				);

example/src/main.ts

@@ -1,4 +1,5 @@
-import { or } from "drizzle-orm";
+import { log } from "node:console";
+import { and, or } from "drizzle-orm";
 import type {
 	GenericDrizzleDbTypeConstraints,
 	QueryConditionObject,
@@ -110,7 +111,16 @@ export const createAbilityBuilder = <
 			} = {} as any;
 
 			const createEntityObject = (entityKey: DBQueryKey) => ({
-				filter: (action: Action) => {
+				filter: (
+					action: Action,
+					options?: {
+						/**
+						 * Additional conditions applied only for this call. Useful for injecting one time additional filters
+						 * for e.g. user args in a handler.
+						 */
+						inject?: QueryConditionObject;
+					},
+				) => {
 					const conditionsPerEntity = registeredConditions[entityKey];
 					if (!conditionsPerEntity) {
 						throw "TODO (No allowed entry found for this condition) #1";
@@ -152,9 +162,16 @@ export const createAbilityBuilder = <
 						}
 					}
 
+					if (options?.inject?.limit && highestLimit < options.inject.limit) {
+						highestLimit = options.inject.limit;
+					}
+
 					let combinedAllowedColumns: Record<string, any> | undefined =
 						undefined;
-					for (const conditionObject of allConditionObjects) {
+					for (const conditionObject of [
+						...allConditionObjects,
+						options?.inject ?? {},
+					]) {
 						if (conditionObject.columns) {
 							if (combinedAllowedColumns === undefined) {
 								combinedAllowedColumns = conditionObject.columns;
@@ -171,16 +188,25 @@ export const createAbilityBuilder = <
 						.filter((o) => o.where)
 						.map((o) => o.where);
 
-					const combinedWhere =
+					let combinedWhere =
 						accumulatedWhereConditions.length > 0
 							? or(...accumulatedWhereConditions)
 							: undefined;
 
-					return {
+					if (options?.inject?.where) {
+						combinedWhere = combinedWhere
+							? and(combinedWhere, options.inject.where)
+							: options.inject.where;
+					}
+
+					const ret = {
 						where: combinedWhere,
 						columns: combinedAllowedColumns,
 						limit: highestLimit,
 					};
+
+					//TODO make this typesafe per actual entity
+					return ret;
 				},
 			});