@m1212e/rumble 0.25.3 → 0.26.1

package/out/index.d.cts

@@ -16,140 +16,6 @@ import { useSofa } from "@m1212e/sofa-api";
 import { ServerOptions } from "graphql-ws";
 import { PhoneNumber } from "libphonenumber-js";
 //#endregion
-//#region lib/helpers/asserts.d.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: (await ctx.abilities.users.filter("read")).single.where,
-             })
-             // note that we need to manually raise an error if the value is not found
-             .then(assertFindFirstExists)
-         );
-       },
-     }),
-   };
- });
- * ```
- */
-export declare const assertFindFirstExists: <T>(value: T | undefined) => T;
-/**
- *
- * 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),
-                (await 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);
-        },
-      }),
-    };
-  });
- * ```
- */
-export declare const assertFirstEntryExists: <T>(value: T[]) => T;
-//#endregion
-//#region lib/helpers/mapNullFieldsToUndefined.d.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(
-              (await ctx.abilities.user.filter('read')).merge(
-                {
-                  where: { id: user.id },
-                }
-              1).query.single,
-            ),
-          )
-          .then(assertFindFirstExists);
-      },
-    }),
- *
- *
- * ```
- */
-export declare function mapNullFieldsToUndefined<T extends object>(obj: T): { [K in keyof T]: T[K] extends null ? undefined : Exclude<T[K], null>; };
-//#endregion
 //#region lib/types/drizzleInstanceType.d.ts
 type DrizzleInstance = PgAsyncDatabase<any, any> | SQLiteAsyncDatabase<any, any, any> | MySqlAsyncDatabase<any, any>;
 /**
@@ -438,6 +304,151 @@ type AbilityFilterResponse<DB extends DrizzleInstance, TableName extends TableRe
   merge: (filters: NonNullable<DrizzleQueryFunctionInput<DB, TableName>>) => AbilityFilter<DB, TableName>;
 };
 //#endregion
+//#region lib/abilityBuilder/inputGuard.d.ts
+type GuardedInput = {
+  where?: unknown;
+  orderBy?: unknown;
+};
+/**
+ * Restricts client supplied `where` and `orderBy` arguments to what the
+ * abilities of the request let the caller read, see `createInputGuard`.
+ */
+export declare function guardFilterInput(abilities: object, table: string, action: string, input: GuardedInput): Promise<GuardedInput>;
+//#endregion
+//#region lib/helpers/asserts.d.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: (await ctx.abilities.users.filter("read")).single.where,
+             })
+             // note that we need to manually raise an error if the value is not found
+             .then(assertFindFirstExists)
+         );
+       },
+     }),
+   };
+ });
+ * ```
+ */
+export declare const assertFindFirstExists: <T>(value: T | undefined) => T;
+/**
+ *
+ * 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),
+                (await 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);
+        },
+      }),
+    };
+  });
+ * ```
+ */
+export declare const assertFirstEntryExists: <T>(value: T[]) => T;
+//#endregion
+//#region lib/helpers/mapNullFieldsToUndefined.d.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(
+              (await ctx.abilities.user.filter('read')).merge(
+                {
+                  where: { id: user.id },
+                }
+              1).query.single,
+            ),
+          )
+          .then(assertFindFirstExists);
+      },
+    }),
+ *
+ *
+ * ```
+ */
+export declare function mapNullFieldsToUndefined<T extends object>(obj: T): { [K in keyof T]: T[K] extends null ? undefined : Exclude<T[K], null>; };
+//#endregion
 //#region lib/scalars/address.d.ts
 /**
  * The shape of a postal address, modeled after the OIDC `address` claim
@@ -4694,6 +4705,7 @@ export declare const rumble: <UserContext extends Record<string, any>, DB extend
       maskColumns: (input: MaskColumnsInput<DB, Action>) => void | Promise<void>;
       maskedActions: (abilities: object, table: TableRelationNames<DB>) => Set<Action>;
       primaryKeyHidden: (abilities: object, row: object) => boolean;
+      columnsHidden: (abilities: object, row: object, columns: string[], primaryKey: string[]) => boolean;
       registerReadAction(table: TableRelationNames<DB>, action: Action): void;
       readActionOf(table: TableRelationNames<DB>): Action;
       registeredFilters({ action, table }: {