@m1212e/rumble 0.11.7 → 0.12.3

package/out/index.d.cts

@@ -0,0 +1,922 @@
+import { GraphQLError, GraphQLSchema } from "graphql";
+import { Client } from "@urql/core";
+import { drizzle } from "drizzle-orm/bun-sqlite";
+import { drizzle as drizzle$1 } from "drizzle-orm/node-postgres";
+import * as drizzle_orm0 from "drizzle-orm";
+import * as graphql_yoga0 from "graphql-yoga";
+import { YogaServerOptions, createPubSub } from "graphql-yoga";
+import * as fets0 from "fets";
+import * as _pothos_plugin_drizzle0 from "@pothos/plugin-drizzle";
+import * as _pothos_core0 from "@pothos/core";
+import SchemaBuilder from "@pothos/core";
+import * as drizzle_orm_pg_core0 from "drizzle-orm/pg-core";
+import { useSofa } from "sofa-api";
+
+//#region lib/client/generate/generate.d.ts
+declare function generateFromSchema({
+  outputPath,
+  schema,
+  rumbleImportPath,
+  apiUrl,
+  useExternalUrqlClient
+}: {
+  schema: GraphQLSchema;
+  outputPath: string;
+  rumbleImportPath?: string;
+  apiUrl?: string;
+  useExternalUrqlClient?: boolean | string;
+}): Promise<void>;
+//#endregion
+//#region lib/client/request.d.ts
+declare const argsKey = "__args";
+//#endregion
+//#region lib/client/utilTypes.d.ts
+type UnArray<T> = T extends Array<infer U> ? U : T;
+type RequireAtLeastOneFieldSet<T> = { [K in keyof T]: Required<Pick<T, K>> & Partial<Omit<T, K>> }[keyof T];
+//#endregion
+//#region lib/client/types.d.ts
+/**
+ * A gql object defined from the generated types.
+ * Most keys are functions that take a selection set and return a promise of the selected data.
+ */
+type QueryableObjectFromGeneratedTypes<Q> = { [Key in keyof Q]: QueryableObjectField$1<Q[Key]> };
+type QueryableObjectField$1<T> = T extends ((p: infer QueryArgs) => infer QueryResponse) ? <Selected extends (QueryArgs extends Record<string, any> ?
+// in that case we want to extend the object with an args key property
+ObjectFieldSelection<UnArray<NonNullable<QueryResponse>>> & {
+  [argsKey]: QueryArgs;
+} : ObjectFieldSelection<UnArray<NonNullable<QueryResponse>>>)>(s: Selected) => QueryResponse extends null ? Response<QueryResponse extends Array<any> ? ApplySelection<NonNullable<UnArray<QueryResponse>>, Selected>[] : ApplySelection<NonNullable<UnArray<QueryResponse>>, Selected>> | null : Response<QueryResponse extends Array<any> ? ApplySelection<UnArray<QueryResponse>, Selected>[] : ApplySelection<UnArray<QueryResponse>, Selected>> : Response<T>;
+/**
+ * The input to select fields for an object
+ */
+type ObjectFieldSelection<O> = RequireAtLeastOneFieldSet<{ [Key in keyof O]: NonNullable<UnArray<O[Key]>> extends ((p: infer P) => infer A) ? P extends Record<string, any> ? ObjectFieldSelection<UnArray<NonNullable<A>>> & {
+  [argsKey]: P;
+} : ObjectFieldSelection<UnArray<NonNullable<A>>> : boolean }>;
+type ApplySelection<Object, Selection> = { [Key in keyof Selection & keyof Object]: Object[Key] extends ((p: infer _P) => infer _A) ? ReturnType<Object[Key]> extends Array<any> ? Array<ApplySelection<UnArray<ReturnType<Object[Key]>>, Selection[Key]>> : ApplySelection<UnArray<Object[Key]>, Selection[Key]> : Object[Key] };
+type Subscribeable<Data> = {
+  subscribe: (subscription: (value: Data) => void) => () => void;
+};
+type Response<Data> = {
+  then: (onFulfilled: (value: Subscribeable<Data> & Data) => void) => void;
+} & Subscribeable<Data | undefined>;
+//#endregion
+//#region lib/client/liveQuery.d.ts
+declare function makeLiveQuery<Query extends Record<string, any>>({
+  urqlClient,
+  availableSubscriptions
+}: {
+  urqlClient: Client;
+  availableSubscriptions: Set<string>;
+}): QueryableObjectFromGeneratedTypes<Query>;
+//#endregion
+//#region lib/client/mutation.d.ts
+declare function makeMutation<Mutation extends Record<string, any>>({
+  urqlClient
+}: {
+  urqlClient: Client;
+}): QueryableObjectFromGeneratedTypes<Mutation>;
+//#endregion
+//#region lib/client/query.d.ts
+declare function makeQuery<Query extends Record<string, any>>({
+  urqlClient
+}: {
+  urqlClient: Client;
+}): QueryableObjectFromGeneratedTypes<Query>;
+//#endregion
+//#region lib/client/subscription.d.ts
+declare function makeSubscription<Subscription extends Record<string, any>>({
+  urqlClient
+}: {
+  urqlClient: Client;
+}): SubscriptionObject<Subscription>;
+type SubscriptionObject<Q> = { [Key in keyof Q]: QueryableObjectField<Q[Key]> };
+type QueryableObjectField<T> = T extends ((p: infer QueryArgs) => infer QueryResponse) ? <Selected extends (QueryArgs extends Record<string, any> ? ObjectFieldSelection<UnArray<NonNullable<QueryResponse>>> & {
+  [argsKey]: QueryArgs;
+} : ObjectFieldSelection<UnArray<NonNullable<QueryResponse>>>)>(s: Selected) => QueryResponse extends null ? Subscribeable<NonNullable<QueryResponse> extends Array<any> ? ApplySelection<UnArray<NonNullable<QueryResponse>>, Selected>[] : ApplySelection<UnArray<NonNullable<QueryResponse>>, Selected>> | null : Subscribeable<QueryResponse extends Array<any> ? ApplySelection<UnArray<QueryResponse>, Selected>[] : ApplySelection<UnArray<QueryResponse>, Selected>> : Subscribeable<T>;
+//#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: ctx.abilities.users.filter("read").single.where,
+             })
+             // note that we need to manually raise an error if the value is not found
+             .then(assertFindFirstExists)
+         );
+       },
+     }),
+   };
+ });
+ * ```
+ */
+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),
+                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);
+        },
+      }),
+    };
+  });
+ * ```
+ */
+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(
+              ctx.abilities.user.filter('read').merge(
+                {
+                  where: { id: user.id },
+                }
+              1).query.single,
+            ),
+          )
+          .then(assertFindFirstExists);
+      },
+    }),
+ *
+ *
+ * ```
+ */
+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 = ReturnType<typeof drizzle$1<any, any, any>> | ReturnType<typeof drizzle<any, any, any>>;
+/**
+ * Type representing the query function of a Drizzle instance.
+ */
+type DrizzleQueryFunction<DB extends DrizzleInstance> = DB["query"];
+/**
+ * Type representing the input parameters for the `findMany` method of a specific table in the Drizzle query function.
+ */
+type DrizzleQueryFunctionInput<DB extends DrizzleInstance, QueryField extends keyof DrizzleQueryFunction<DB>> = Parameters<DrizzleQueryFunction<DB>[QueryField]["findMany"]>[0];
+/**
+ * Type representing the type of a record in a specific table of the Drizzle instance.
+ */
+type DrizzleTableValueType<DB extends DrizzleInstance, QueryField extends keyof DrizzleQueryFunction<DB>> = NonNullable<Awaited<ReturnType<DrizzleQueryFunction<DB>[QueryField]["findFirst"]>>>;
+//#endregion
+//#region lib/runtimeFiltersPlugin/filterTypes.d.ts
+type Filter<Context, T> = (p: {
+  context: Context;
+  entities: T[];
+}) => T[] | Promise<T[]>;
+//#endregion
+//#region lib/args/whereArgsImplementer.d.ts
+type NumberWhereInputArgument = {
+  eq?: number;
+  ne?: number;
+  gt?: number;
+  gte?: number;
+  lt?: number;
+  lte?: number;
+  in?: number[];
+  notIn?: number[];
+  like?: string;
+  ilike?: string;
+  notLike?: string;
+  notIlike?: string;
+  isNull?: boolean;
+  isNotNull?: boolean;
+  arrayOverlaps?: number[];
+  arrayContained?: number[];
+  arrayContains?: number[];
+  AND?: NumberWhereInputArgument[];
+  OR?: NumberWhereInputArgument[];
+  NOT?: NumberWhereInputArgument;
+};
+type StringWhereInputArgument = {
+  eq?: string;
+  ne?: string;
+  gt?: string;
+  gte?: string;
+  lt?: string;
+  lte?: string;
+  in?: string[];
+  notIn?: string[];
+  like?: string;
+  ilike?: string;
+  notLike?: string;
+  notIlike?: string;
+  isNull?: boolean;
+  isNotNull?: boolean;
+  arrayOverlaps?: string[];
+  arrayContained?: string[];
+  arrayContains?: string[];
+  AND?: StringWhereInputArgument[];
+  OR?: StringWhereInputArgument[];
+  NOT?: StringWhereInputArgument;
+};
+type DateWhereInputArgument = {
+  eq?: Date;
+  ne?: Date;
+  gt?: Date;
+  gte?: Date;
+  lt?: Date;
+  lte?: Date;
+  in?: Date[];
+  notIn?: Date[];
+  like?: string;
+  ilike?: string;
+  notLike?: string;
+  notIlike?: string;
+  isNull?: boolean;
+  isNotNull?: boolean;
+  arrayOverlaps?: Date[];
+  arrayContained?: Date[];
+  arrayContains?: Date[];
+  AND?: DateWhereInputArgument[];
+  OR?: DateWhereInputArgument[];
+  NOT?: DateWhereInputArgument;
+};
+//#endregion
+//#region lib/types/rumbleInput.d.ts
+type CustomRumblePothosConfig = Omit<ConstructorParameters<typeof SchemaBuilder>[0], "smartSubscriptions" | "drizzle">;
+type RumbleInput<UserContext extends Record<string, any>, DB extends DrizzleInstance, RequestEvent extends Record<string, any>, Action extends string, PothosConfig extends CustomRumblePothosConfig> = {
+  /**
+   * Your drizzle database instance
+   */
+  db: DB;
+  /**
+   * A function for providing context for each request based on the incoming HTTP Request.
+   * The type of the parameter equals the HTTPRequest type of your chosen server.
+   */
+  context?: ((event: RequestEvent) => Promise<UserContext> | UserContext) | undefined;
+  /**
+   * If you only want to disable query, mutation or subscription default objects, you can do so here
+   */
+  disableDefaultObjects?: {
+    mutation?: boolean;
+    subscription?: boolean;
+    query?: boolean;
+  };
+  /**
+   * The actions that are available
+   */
+  actions?: Action[];
+  /**
+   * Customization for subscriptions. See https://the-guild.dev/graphql/yoga-server/docs/features/subscriptions#distributed-pubsub-for-production
+   */
+  subscriptions?: Parameters<typeof createPubSub>;
+  /**
+   * Options passed along to the pothos schema builder.
+   */
+  pothosConfig?: PothosConfig;
+  /**
+   * Limits the returned amount when querying lists. Set to null to disable.
+   * @default 100
+   */
+  defaultLimit?: number | undefined | null;
+  /**
+   * rumble supports fuzzy search for the query helpers. This enables the users of your API to search for entities via fuzzy search inputs.
+   * This currently only is supported by postgres databases and will fail if enabled on other dialects.
+   *
+   * Please note that this will install the pg_trgm extension on startup if your database does not have it already installed.
+   * https://www.postgresql.org/docs/current/pgtrgm.html
+   */
+  search?: {
+    /**
+     * Whether search is enabled
+     */
+    enabled?: boolean;
+    /**
+     * The threshold for cutting off non matching results. Defaults to 0.1. Lower = more results.
+     */
+    threshold?: number;
+  } | undefined;
+};
+//#endregion
+//#region lib/rumble.d.ts
+declare const rumble: <UserContext extends Record<string, any>, DB extends DrizzleInstance, RequestEvent extends Record<string, any>, PothosConfig extends CustomRumblePothosConfig, Action extends string = "read" | "update" | "delete">(rumbleInput: RumbleInput<UserContext, DB, RequestEvent, Action, PothosConfig>) => {
+  /**
+     * The ability builder. Use it to declare whats allowed for each entity in your DB.
+     *
+     * @example
+     *
+     * ```ts
+     * // users can edit themselves
+     abilityBuilder.users
+       .allow(["read", "update", "delete"])
+       .when(({ userId }) => ({ where: eq(schema.users.id, userId) }));
+     
+     // everyone can read posts
+     abilityBuilder.posts.allow("read");
+     *
+     * ```
+     */
+  abilityBuilder: (keyof DrizzleQueryFunction<DB> extends infer T extends keyof DrizzleQueryFunction<DB> ? { [key in T]: {
+    allow: (action: Action | Action[]) => {
+      when: (queryFilter: DrizzleQueryFunctionInput<DB, key> | ((context: UserContext) => DrizzleQueryFunctionInput<DB, key> | "allow" | undefined)) => void;
+    };
+    filter: (action: Action | Action[]) => {
+      by: (explicitFilter: Filter<UserContext, DrizzleTableValueType<DB, key>>) => void;
+    };
+    _: {
+      runtimeFilters: Map<Action, Filter<UserContext, any>[]>;
+      queryFilters: Map<Action, "unrestricted" | (DrizzleQueryFunctionInput<DB, key> | ((context: UserContext) => DrizzleQueryFunctionInput<DB, key> | "allow" | undefined))[]>;
+    };
+  } } : never) & {
+    _: {
+      registeredFilters({
+        action,
+        table
+      }: {
+        table: keyof DrizzleQueryFunction<DB>;
+        action: Action;
+      }): Filter<UserContext, DrizzleTableValueType<DB, keyof DrizzleQueryFunction<DB>>>[];
+      build(): (ctx: UserContext) => keyof DrizzleQueryFunction<DB> extends infer T_1 extends keyof DrizzleQueryFunction<DB> ? { [key_1 in T_1]: {
+        filter: (action: Action) => {
+          query: {
+            single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
+            many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+          };
+          sql: {
+            readonly where: drizzle_orm0.SQL<unknown> | undefined;
+          };
+        } & {
+          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
+            query: {
+              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
+              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+            };
+            sql: {
+              readonly where: drizzle_orm0.SQL<unknown> | undefined;
+            };
+          };
+        };
+      } } : never;
+    };
+  };
+  /**
+   * The pothos schema builder. See https://pothos-graphql.dev/docs/plugins/drizzle
+   */
+  schemaBuilder: PothosSchemaTypes.SchemaBuilder<PothosSchemaTypes.ExtendDefaultTypes<{
+    Context: Awaited<UserContext & {
+      abilities: keyof DrizzleQueryFunction<DB> extends infer T_1 extends keyof DrizzleQueryFunction<DB> ? { [key_1 in T_1]: {
+        filter: (action: Action) => {
+          query: {
+            single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
+            many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+          };
+          sql: {
+            readonly where: drizzle_orm0.SQL<unknown> | undefined;
+          };
+        } & {
+          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
+            query: {
+              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
+              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+            };
+            sql: {
+              readonly where: drizzle_orm0.SQL<unknown> | undefined;
+            };
+          };
+        };
+      } } : never;
+    }>;
+    DrizzleRelations: DB["_"]["relations"];
+    Scalars: {
+      JSON: {
+        Input: unknown;
+        Output: unknown;
+      };
+      Date: {
+        Input: Date;
+        Output: Date;
+      };
+      DateTime: {
+        Input: Date;
+        Output: Date;
+      };
+    };
+    Inputs: {
+      IntWhereInputArgument: NumberWhereInputArgument;
+      FloatWhereInputArgument: NumberWhereInputArgument;
+      StringWhereInputArgument: StringWhereInputArgument;
+      DateWhereInputArgument: DateWhereInputArgument;
+    };
+  }>>;
+  /**
+     * Creates the native yoga instance. Can be used to run an actual HTTP server.
+     *
+     * @example
+     *
+     * ```ts
+     *
+      import { createServer } from "node:http";
+      * const server = createServer(createYoga());
+      server.listen(3000, () => {
+          console.info("Visit http://localhost:3000/graphql");
+          });
+          * ```
+     * https://the-guild.dev/graphql/yoga-server/docs#server
+     */
+  createYoga: (args?: (Omit<YogaServerOptions<RequestEvent, any>, "schema" | "context"> & {
+    /**
+     * Determines if the API should disclose various things about its structure.
+     * Defaults to `process.env.NODE_ENV === "development"`.
+     * If enabled, the api will allow introspection requests, provide the graphiql
+     * explorer and will not apply the additional envelop armor plugin.
+     */
+    enableApiDocs?: boolean;
+  }) | undefined) => graphql_yoga0.YogaServerInstance<RequestEvent, {}>;
+  /**
+       * Creates a sofa instance to offer a REST API.
+      ```ts
+      import express from 'express';
+      
+      const app = express();
+      const sofa = createSofa(...);
+      
+      app.use('/api', useSofa({ schema }));
+      ```
+      * https://the-guild.dev/graphql/sofa-api/docs#usage
+       */
+  createSofa: (args: Omit<Parameters<typeof useSofa>[0], "schema" | "context">) => fets0.Router<any, {}, {
+    [TKey: string]: never;
+  }>;
+  /**
+   * A function for creating default objects for your schema
+   */
+  object: <TableName extends keyof DrizzleQueryFunction<DB>, RefName extends string>({
+    table,
+    refName,
+    readAction,
+    adjust
+  }: {
+    table: TableName;
+    refName?: RefName | undefined;
+    readAction?: Action | undefined;
+    adjust?: ((t: _pothos_plugin_drizzle0.DrizzleObjectFieldBuilder<PothosSchemaTypes.ExtendDefaultTypes<{
+      Context: Awaited<UserContext & {
+        abilities: keyof DrizzleQueryFunction<DB> extends infer T_2 extends keyof DrizzleQueryFunction<DB> ? { [key_1 in T_2]: {
+          filter: (action: Action) => {
+            query: {
+              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
+              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+            };
+            sql: {
+              readonly where: drizzle_orm0.SQL<unknown> | undefined;
+            };
+          } & {
+            merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
+              query: {
+                single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
+                many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+              };
+              sql: {
+                readonly where: drizzle_orm0.SQL<unknown> | undefined;
+              };
+            };
+          };
+        } } : never;
+      }>;
+      DrizzleRelations: DB["_"]["relations"];
+      Scalars: {
+        JSON: {
+          Input: unknown;
+          Output: unknown;
+        };
+        Date: {
+          Input: Date;
+          Output: Date;
+        };
+        DateTime: {
+          Input: Date;
+          Output: Date;
+        };
+      };
+      Inputs: {
+        IntWhereInputArgument: NumberWhereInputArgument;
+        FloatWhereInputArgument: NumberWhereInputArgument;
+        StringWhereInputArgument: StringWhereInputArgument;
+        DateWhereInputArgument: DateWhereInputArgument;
+      };
+    }>, (DB["_"]["relations"] & {})[TableName], DrizzleTableValueType<DB, TableName>, { [Key in keyof Extract<(DB["_"]["relations"] & {})[TableName]["table"], {
+      _: {
+        brand: "Table";
+      };
+    }>["_"]["columns"] & string]: Extract<(DB["_"]["relations"] & {})[TableName]["table"], {
+      _: {
+        brand: "Table";
+      };
+    }>["_"]["columns"][Key]["_"]["notNull"] extends true ? Extract<(DB["_"]["relations"] & {})[TableName]["table"], {
+      _: {
+        brand: "Table";
+      };
+    }>["_"]["columns"][Key]["_"]["data"] : Extract<(DB["_"]["relations"] & {})[TableName]["table"], {
+      _: {
+        brand: "Table";
+      };
+    }>["_"]["columns"][Key]["_"]["data"] | null } extends infer T_3 ? { [K in keyof T_3]: { [Key in keyof Extract<(DB["_"]["relations"] & {})[TableName]["table"], {
+      _: {
+        brand: "Table";
+      };
+    }>["_"]["columns"] & string]: Extract<(DB["_"]["relations"] & {})[TableName]["table"], {
+      _: {
+        brand: "Table";
+      };
+    }>["_"]["columns"][Key]["_"]["notNull"] extends true ? Extract<(DB["_"]["relations"] & {})[TableName]["table"], {
+      _: {
+        brand: "Table";
+      };
+    }>["_"]["columns"][Key]["_"]["data"] : Extract<(DB["_"]["relations"] & {})[TableName]["table"], {
+      _: {
+        brand: "Table";
+      };
+    }>["_"]["columns"][Key]["_"]["data"] | null }[K] } : never>) => _pothos_core0.FieldMap) | undefined;
+  }) => _pothos_plugin_drizzle0.DrizzleObjectRef<PothosSchemaTypes.ExtendDefaultTypes<{
+    Context: Awaited<UserContext & {
+      abilities: keyof DrizzleQueryFunction<DB> extends infer T_2 extends keyof DrizzleQueryFunction<DB> ? { [key_1 in T_2]: {
+        filter: (action: Action) => {
+          query: {
+            single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
+            many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+          };
+          sql: {
+            readonly where: drizzle_orm0.SQL<unknown> | undefined;
+          };
+        } & {
+          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
+            query: {
+              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
+              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+            };
+            sql: {
+              readonly where: drizzle_orm0.SQL<unknown> | undefined;
+            };
+          };
+        };
+      } } : never;
+    }>;
+    DrizzleRelations: DB["_"]["relations"];
+    Scalars: {
+      JSON: {
+        Input: unknown;
+        Output: unknown;
+      };
+      Date: {
+        Input: Date;
+        Output: Date;
+      };
+      DateTime: {
+        Input: Date;
+        Output: Date;
+      };
+    };
+    Inputs: {
+      IntWhereInputArgument: NumberWhereInputArgument;
+      FloatWhereInputArgument: NumberWhereInputArgument;
+      StringWhereInputArgument: StringWhereInputArgument;
+      DateWhereInputArgument: DateWhereInputArgument;
+    };
+  }>, TableName, drizzle_orm0.BuildQueryResult<DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})[TableName], true extends true | drizzle_orm0.DBQueryConfig<"one", DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})[TableName]> ? true : (true | drizzle_orm0.DBQueryConfig<"one", DB["_"]["relations"] & {}, (DB["_"]["relations"] & {})[TableName]>) & {
+    columns: {};
+  }, drizzle_orm0.Assume<(DB["_"]["relations"] & {})[TableName]["table"], {
+    $inferSelect: Record<string, unknown>;
+  }>["$inferSelect"]>>;
+  /**
+   * A function for creating where args to filter entities
+   */
+  whereArg: <TableName extends keyof DrizzleQueryFunction<DB>, RefName_1 extends string>({
+    table,
+    refName,
+    dbName
+  }: Partial<{
+    table: TableName;
+    refName: RefName_1 | undefined;
+    dbName: string;
+  }> & ({
+    dbName: string;
+  } | {
+    table: TableName;
+  })) => PothosSchemaTypes.InputObjectRef<PothosSchemaTypes.ExtendDefaultTypes<{
+    Context: Awaited<UserContext & {
+      abilities: keyof DrizzleQueryFunction<DB> extends infer T_2 extends keyof DrizzleQueryFunction<DB> ? { [key_1 in T_2]: {
+        filter: (action: Action) => {
+          query: {
+            single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
+            many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+          };
+          sql: {
+            readonly where: drizzle_orm0.SQL<unknown> | undefined;
+          };
+        } & {
+          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
+            query: {
+              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
+              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+            };
+            sql: {
+              readonly where: drizzle_orm0.SQL<unknown> | undefined;
+            };
+          };
+        };
+      } } : never;
+    }>;
+    DrizzleRelations: DB["_"]["relations"];
+    Scalars: {
+      JSON: {
+        Input: unknown;
+        Output: unknown;
+      };
+      Date: {
+        Input: Date;
+        Output: Date;
+      };
+      DateTime: {
+        Input: Date;
+        Output: Date;
+      };
+    };
+    Inputs: {
+      IntWhereInputArgument: NumberWhereInputArgument;
+      FloatWhereInputArgument: NumberWhereInputArgument;
+      StringWhereInputArgument: StringWhereInputArgument;
+      DateWhereInputArgument: DateWhereInputArgument;
+    };
+  }>, {
+    [x: string]: unknown;
+  }>;
+  /**
+   * A function for creating order args to sort entities
+   */
+  orderArg: <RefName_2 extends string, TableName extends keyof DrizzleQueryFunction<DB>>({
+    table,
+    refName,
+    dbName
+  }: Partial<{
+    table: TableName;
+    refName: RefName_2 | undefined;
+    dbName: string;
+  }> & ({
+    dbName: string;
+  } | {
+    table: TableName;
+  })) => PothosSchemaTypes.InputObjectRef<PothosSchemaTypes.ExtendDefaultTypes<{
+    Context: Awaited<UserContext & {
+      abilities: keyof DrizzleQueryFunction<DB> extends infer T_2 extends keyof DrizzleQueryFunction<DB> ? { [key_1 in T_2]: {
+        filter: (action: Action) => {
+          query: {
+            single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
+            many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+          };
+          sql: {
+            readonly where: drizzle_orm0.SQL<unknown> | undefined;
+          };
+        } & {
+          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
+            query: {
+              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
+              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+            };
+            sql: {
+              readonly where: drizzle_orm0.SQL<unknown> | undefined;
+            };
+          };
+        };
+      } } : never;
+    }>;
+    DrizzleRelations: DB["_"]["relations"];
+    Scalars: {
+      JSON: {
+        Input: unknown;
+        Output: unknown;
+      };
+      Date: {
+        Input: Date;
+        Output: Date;
+      };
+      DateTime: {
+        Input: Date;
+        Output: Date;
+      };
+    };
+    Inputs: {
+      IntWhereInputArgument: NumberWhereInputArgument;
+      FloatWhereInputArgument: NumberWhereInputArgument;
+      StringWhereInputArgument: StringWhereInputArgument;
+      DateWhereInputArgument: DateWhereInputArgument;
+    };
+  }>, {
+    [x: string]: unknown;
+  }>;
+  /**
+   * A function for creating default READ queries.
+   * Make sure the objects for the table you are creating the queries for are implemented
+   */
+  query: <TableName_1 extends keyof DrizzleQueryFunction<DB>>({
+    table,
+    readAction,
+    listAction
+  }: {
+    table: TableName_1;
+    readAction?: Action | undefined;
+    listAction?: Action | undefined;
+  }) => void;
+  /**
+   * A function for creating a pubsub instance for a table. Use this to publish or subscribe events
+   */
+  pubsub: <TableName_1 extends keyof DrizzleQueryFunction<DB>>({
+    table
+  }: {
+    table: TableName_1;
+  }) => {
+    registerOnInstance({
+      instance,
+      action,
+      primaryKeyValue
+    }: {
+      instance: {
+        register: (id: string) => void;
+      };
+      action: "created" | "removed" | "updated";
+      primaryKeyValue?: string;
+    }): void;
+    created(): void;
+    removed(): void;
+    updated(primaryKeyValue?: any | any[]): void;
+  };
+  /**
+   * A function to implement enums for graphql usage.
+   * The other helpers use this helper internally so in most cases you do not have to
+   * call this helper directly, unless you need the reference to an enum type
+   */
+  enum_: <ExplicitEnumVariableName extends keyof (NonNullable<DB["_"]["relations"]["schema"]> extends infer T_2 ? { [K in keyof T_2 as NonNullable<DB["_"]["relations"]["schema"]>[K] extends drizzle_orm_pg_core0.PgEnum<any> ? K : never]: NonNullable<DB["_"]["relations"]["schema"]>[K] } : never), EnumColumn extends drizzle_orm_pg_core0.PgEnum<any>, RefName_2 extends string>({
+    tsName,
+    enumColumn,
+    refName
+  }: Partial<{
+    tsName: ExplicitEnumVariableName;
+    enumColumn: EnumColumn;
+    refName?: RefName_2 | undefined;
+  }> & ({
+    tsName: ExplicitEnumVariableName;
+  } | {
+    enumColumn: EnumColumn;
+  })) => PothosSchemaTypes.EnumRef<PothosSchemaTypes.ExtendDefaultTypes<{
+    Context: Awaited<UserContext & {
+      abilities: keyof DrizzleQueryFunction<DB> extends infer T_3 extends keyof DrizzleQueryFunction<DB> ? { [key_1 in T_3]: {
+        filter: (action: Action) => {
+          query: {
+            single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
+            many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+          };
+          sql: {
+            readonly where: drizzle_orm0.SQL<unknown> | undefined;
+          };
+        } & {
+          merge: (p: NonNullable<DrizzleQueryFunctionInput<DB, key_1>>) => {
+            query: {
+              single: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findFirst"]>[0]>>, "where">;
+              many: Pick<NonNullable<NonNullable<Parameters<DB["query"][key_1]["findMany"]>[0]>>, "where" | "limit">;
+            };
+            sql: {
+              readonly where: drizzle_orm0.SQL<unknown> | undefined;
+            };
+          };
+        };
+      } } : never;
+    }>;
+    DrizzleRelations: DB["_"]["relations"];
+    Scalars: {
+      JSON: {
+        Input: unknown;
+        Output: unknown;
+      };
+      Date: {
+        Input: Date;
+        Output: Date;
+      };
+      DateTime: {
+        Input: Date;
+        Output: Date;
+      };
+    };
+    Inputs: {
+      IntWhereInputArgument: NumberWhereInputArgument;
+      FloatWhereInputArgument: NumberWhereInputArgument;
+      StringWhereInputArgument: StringWhereInputArgument;
+      DateWhereInputArgument: DateWhereInputArgument;
+    };
+  }>, any, any>;
+  /**
+   * Create a client to consume a rumble graphql api at the specified location.
+   * Requires GraphQL, does not work with the SOFA REST API.
+   */
+  clientCreator: ({
+    apiUrl,
+    outputPath,
+    rumbleImportPath,
+    useExternalUrqlClient
+  }: {
+    outputPath: string;
+    apiUrl?: string;
+    rumbleImportPath?: string;
+    useExternalUrqlClient?: string;
+  }) => Promise<void>;
+};
+//#endregion
+//#region lib/types/rumbleError.d.ts
+/**
+ * An error that gets raised by rumble whenever something does not go according to plan.
+ * Mostly internals, configuration errors or other unexpected things.
+ */
+declare class RumbleError extends Error {
+  constructor(message: string);
+}
+/**
+ * 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.
+ */
+declare class RumbleErrorSafe extends GraphQLError {}
+//#endregion
+export { RumbleError, RumbleErrorSafe, assertFindFirstExists, assertFirstEntryExists, generateFromSchema, makeLiveQuery, makeMutation, makeQuery, makeSubscription, mapNullFieldsToUndefined, rumble };
+//# sourceMappingURL=index.d.cts.map