@vantreeseba/drizzle-graphql 1.0.3 → 3.0.0

package/dist/index.d.cts

@@ -1,9 +1,20 @@
-import { Table, Column, SQL, Relation, One, Many } from 'drizzle-orm';
+import { Table, Column, Relation, SQL, One, Many } from 'drizzle-orm';
 import { MySqlDatabase } from 'drizzle-orm/mysql-core';
 import { PgAsyncDatabase } from 'drizzle-orm/pg-core';
 import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
-import { GraphQLResolveInfo, GraphQLSchema, GraphQLInputObjectType, GraphQLObjectType, GraphQLNonNull, GraphQLList, GraphQLScalarType } from 'graphql';
+import { GraphQLFieldResolver, GraphQLResolveInfo, GraphQLSchema, GraphQLInputObjectType, GraphQLObjectType, GraphQLNonNull, GraphQLList, GraphQLScalarType, GraphQLEnumType } from 'graphql';
+export { GraphQLDate, GraphQLDateTime, GraphQLJSON, GraphQLUUID } from 'graphql-scalars';
 
+type TableNamedRelations = {
+    relation: Relation;
+    targetTableName: string;
+    /**
+     * Property names of the target table's primary key, resolved at build time (composite
+     * keys included, via the dialect's getTableConfig). Used to default paginated relations
+     * to a deterministic PK order. Empty when the target has no detectable primary key.
+     */
+    targetPkNames?: readonly string[];
+};
 type ColTypeIsNull<TColumn extends Column, TColType> = TColumn['_']['notNull'] extends true ? TColType : TColType | null;
 type ColTypeIsNullOrUndefinedWithDefault<TColumn extends Column, TColType> = TColumn['_']['notNull'] extends true ? TColumn['_']['hasDefault'] extends true ? TColType | null | undefined : TColumn['defaultFn'] extends undefined ? TColType : TColType | null | undefined : TColType | null | undefined;
 type GetColumnGqlDataType<TColumn extends Column> = TColumn['dataType'] extends 'boolean' ? ColTypeIsNull<TColumn, boolean> : TColumn['dataType'] extends 'json' ? TColumn['_']['columnType'] extends 'PgGeometryObject' ? ColTypeIsNull<TColumn, {
@@ -62,8 +73,83 @@ type OrderByArgs<TTable extends Table> = {
     };
 };
 
+/**
+ * Extracts the join column info from a drizzle-orm v1 Relation object.
+ * Returns the JS property name of the local column on the parent table and the
+ * Column object for the foreign column on the target table, or undefined if the
+ * relation internals are not accessible.
+ */
+declare const extractRelationJoinColumns: (relEntry: TableNamedRelations, parentTable: Table, targetTable: Table) => {
+    localColPropName: string;
+    foreignCol: Column;
+    foreignColPropName: string;
+} | undefined;
+type RelationResolverFactory = (params: {
+    tableName: string;
+    relationName: string;
+    relEntry: TableNamedRelations;
+    isOne: boolean;
+}) => GraphQLFieldResolver<any, any> | undefined;
+/**
+ * Key on the GraphQL context object under which a caller can place a Drizzle transaction
+ * (or any other executor: a pooled connection, a logging proxy). Every generated resolver
+ * reads it at resolve time and runs its statements there instead of on the database the
+ * schema was built from, which is what lets several mutations in one request share a
+ * transaction and lets a query see that transaction's uncommitted rows:
+ *
+ * ```ts
+ * await db.transaction(async (tx) => {
+ *   await graphql({ schema, source, contextValue: { [drizzleExecutorKey]: tx } });
+ * });
+ * ```
+ *
+ * Registered with `Symbol.for` so the ESM and CJS builds of this package agree on it when
+ * both end up loaded in one process.
+ */
+declare const drizzleExecutorKey: unique symbol;
+/**
+ * Creates a RelationResolverFactory that generates field-level resolvers for each relation.
+ * Each resolver:
+ *   1. Returns pre-fetched data if the parent resolver already included it (eager path, zero cost).
+ *   2. When limit/offset args are present, falls back to a direct per-item query.
+ *   3. Otherwise batches all sibling resolver calls within the same GraphQL execution tick
+ *      into a single IN-clause query, eliminating N+1 database round-trips.
+ */
+declare const createRelationResolverFactory: (db: any, tables: Record<string, Table>, filterCtx?: RelationFilterBase) => RelationResolverFactory;
 declare const extractOrderBy: <TTable extends Table, TArgs extends OrderByArgs<any> = OrderByArgs<TTable>>(table: TTable, orderArgs: TArgs) => SQL[];
-declare const extractFilters: <TTable extends Table>(table: TTable, tableName: string, filters: Filters<TTable>) => SQL | undefined;
+/**
+ * Everything `extractFilters` needs to turn a relation key in a `where` argument into a
+ * correlated subquery. Omitted by callers that don't generate relation filters, in which case
+ * relation keys can't appear in the input to begin with.
+ */
+interface RelationFilterContext {
+    /** Every table in the schema, keyed by its schema key. */
+    tables: Record<string, Table>;
+    /** Relations keyed by table schema key, then relation name. */
+    relationMap: Record<string, Record<string, TableNamedRelations>>;
+    /**
+     * Schema key of the table being filtered. Not always the same as the `tableName` label
+     * used in error messages (relation `where` callbacks pass the relation name there).
+     */
+    tableKey: string;
+    /** Shared counter making every subquery alias unique within one extraction. */
+    aliases?: {
+        n: number;
+    };
+}
+/**
+ * The build-scoped half of {@link RelationFilterContext}. Created once per generated schema and
+ * handed to every resolver, which adds the table it is filtering.
+ */
+type RelationFilterBase = Pick<RelationFilterContext, 'tables' | 'relationMap'>;
+declare const extractFilters: <TTable extends Table>(table: TTable, tableName: string, filters: Filters<TTable>, relationCtx?: RelationFilterContext) => SQL | undefined;
+/**
+ * Default for `config.onError`: keeps drizzle-graphql's own errors, which are written for
+ * the client, and replaces driver/database errors with a generic message. Their text names
+ * tables, columns, constraints and offending values, none of which belongs in a response.
+ * The original is preserved on `originalError` for server-side logging.
+ */
+declare const defaultErrorMapper: (error: unknown) => unknown;
 
 type Relations<TTable extends string = string, TConfig extends Record<string, Relation> = Record<string, Relation>> = {
     table: {
@@ -108,6 +194,22 @@ type UpdateArgs<TTable extends Table> = Partial<{
     set: GetRemappedTableUpdateDataType<TTable>;
     where?: Filters<TTable>;
 }>;
+/**
+ * The `onConflict` argument of the generated upsert mutations.
+ *
+ * `target` and `where` exist on PostgreSQL and SQLite only: MySQL's
+ * `ON DUPLICATE KEY UPDATE` fires on whichever unique key was violated and takes no
+ * predicate, so neither field is generated there.
+ */
+type UpsertConflictArgs<TTable extends Table> = {
+    action?: 'UPDATE' | 'NOTHING';
+    target?: string[];
+    update?: string[];
+    where?: Filters<TTable>;
+};
+type UpsertArgs<TTable extends Table, isSingle extends boolean> = InsertArgs<TTable, isSingle> & {
+    onConflict?: UpsertConflictArgs<TTable>;
+};
 type DeleteArgs<TTable extends Table> = {
     where?: Filters<TTable>;
 };
@@ -120,6 +222,18 @@ type SelectSingleResolver<TTable extends Table, TTables extends Record<string, T
 type InsertResolver<TTable extends Table, IsReturnless extends boolean> = (source: any, args: Partial<InsertArgs<TTable, false>>, context: any, info: GraphQLResolveInfo) => Promise<IsReturnless extends false ? Array<GetRemappedTableDataType<TTable>> : MutationReturnlessResult>;
 type InsertArrResolver<TTable extends Table, IsReturnless extends boolean> = (source: any, args: Partial<InsertArgs<TTable, true>>, context: any, info: GraphQLResolveInfo) => Promise<IsReturnless extends false ? GetRemappedTableDataType<TTable> | undefined : MutationReturnlessResult>;
 type UpdateResolver<TTable extends Table, IsReturnless extends boolean> = (source: any, args: UpdateArgs<TTable>, context: any, info: GraphQLResolveInfo) => Promise<IsReturnless extends false ? GetRemappedTableDataType<TTable> | undefined : MutationReturnlessResult>;
+/** Resolver for `upsert<Table>Single`. */
+type UpsertResolver<TTable extends Table, IsReturnless extends boolean> = (source: any, args: Partial<UpsertArgs<TTable, true>>, context: any, info: GraphQLResolveInfo) => Promise<IsReturnless extends false ? GetRemappedTableDataType<TTable> | undefined : MutationReturnlessResult>;
+/** Resolver for `upsert<Table>`. */
+type UpsertArrResolver<TTable extends Table, IsReturnless extends boolean> = (source: any, args: Partial<UpsertArgs<TTable, false>>, context: any, info: GraphQLResolveInfo) => Promise<IsReturnless extends false ? Array<GetRemappedTableDataType<TTable>> : MutationReturnlessResult>;
+/**
+ * Resolver for a table's generated aggregate query (`<plural>Aggregate`).
+ * Returns only the requested aggregations: `count` plus per-column `avg` / `sum`
+ * (numeric columns, as Float) and `min` / `max` (orderable columns, as the column's type).
+ */
+type AggregateResolver<TTable extends Table> = (source: any, args: {
+    where?: Filters<TTable>;
+}, context: any, info: GraphQLResolveInfo) => Promise<Record<string, any>>;
 type DeleteResolver<TTable extends Table, IsReturnless extends boolean> = (source: any, args: DeleteArgs<TTable>, context: any, info: GraphQLResolveInfo) => Promise<IsReturnless extends false ? GetRemappedTableDataType<TTable> | undefined : MutationReturnlessResult>;
 type QueriesCore<TSchemaTables extends Record<string, Table>, TSchemaRelations extends Record<string, Relations>, TInputs extends Record<string, GraphQLInputObjectType>, TOutputs extends Record<string, GraphQLObjectType>> = {
     [TName in keyof TSchemaTables as TName extends string ? `${Uncapitalize<TName>}` : never]: TName extends string ? {
@@ -137,6 +251,9 @@ type QueriesCore<TSchemaTables extends Record<string, Table>, TSchemaRelations e
             where: {
                 type: TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never;
             };
+            distinct: {
+                type: GraphQLList<GraphQLNonNull<GraphQLEnumType>>;
+            };
         };
         resolve: SelectResolver<TSchemaTables[TName], TSchemaTables, ExtractTableRelations<TSchemaTables[TName], TSchemaRelations> extends infer R ? R[keyof R] : never>;
     } : never;
@@ -156,9 +273,19 @@ type QueriesCore<TSchemaTables extends Record<string, Table>, TSchemaRelations e
         };
         resolve: SelectSingleResolver<TSchemaTables[TName], TSchemaTables, ExtractTableRelations<TSchemaTables[TName], TSchemaRelations> extends infer R ? R[keyof R] : never>;
     } : never;
+} & {
+    [TName in keyof TSchemaTables as TName extends string ? `${Uncapitalize<TName>}Aggregate` : never]: TName extends string ? {
+        type: GraphQLNonNull<TOutputs[`${Capitalize<TName>}Aggregate`] extends GraphQLObjectType ? TOutputs[`${Capitalize<TName>}Aggregate`] : GraphQLObjectType>;
+        args: {
+            where: {
+                type: TInputs[`${Capitalize<TName>}Filters`] extends GraphQLInputObjectType ? TInputs[`${Capitalize<TName>}Filters`] : never;
+            };
+        };
+        resolve: AggregateResolver<TSchemaTables[TName]>;
+    } : never;
 };
 type MutationsCore<TSchemaTables extends Record<string, Table>, TInputs extends Record<string, GraphQLInputObjectType>, TOutputs extends Record<string, GraphQLObjectType>, IsReturnless extends boolean> = {
-    [TName in keyof TSchemaTables as TName extends string ? `insertInto${Capitalize<TName>}` : never]: TName extends string ? {
+    [TName in keyof TSchemaTables as TName extends string ? `create${Capitalize<TName>}` : never]: TName extends string ? {
         type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[`${Capitalize<TName>}Item`]>>>;
         args: {
             values: {
@@ -168,7 +295,7 @@ type MutationsCore<TSchemaTables extends Record<string, Table>, TInputs extends
         resolve: InsertArrResolver<TSchemaTables[TName], IsReturnless>;
     } : never;
 } & {
-    [TName in keyof TSchemaTables as TName extends string ? `insertInto${Capitalize<TName>}Single` : never]: TName extends string ? {
+    [TName in keyof TSchemaTables as TName extends string ? `create${Capitalize<TName>}Single` : never]: TName extends string ? {
         type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : TOutputs[`${Capitalize<TName>}Item`];
         args: {
             values: {
@@ -177,6 +304,32 @@ type MutationsCore<TSchemaTables extends Record<string, Table>, TInputs extends
         };
         resolve: InsertResolver<TSchemaTables[TName], IsReturnless>;
     } : never;
+} & {
+    [TName in keyof TSchemaTables as TName extends string ? `upsert${Capitalize<TName>}` : never]?: TName extends string ? {
+        type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[`${Capitalize<TName>}Item`]>>>;
+        args: {
+            values: {
+                type: GraphQLNonNull<GraphQLList<GraphQLNonNull<TInputs[`${Capitalize<TName>}InsertInput`]>>>;
+            };
+            onConflict: {
+                type: GraphQLInputObjectType;
+            };
+        };
+        resolve: UpsertArrResolver<TSchemaTables[TName], IsReturnless>;
+    } : never;
+} & {
+    [TName in keyof TSchemaTables as TName extends string ? `upsert${Capitalize<TName>}Single` : never]?: TName extends string ? {
+        type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : TOutputs[`${Capitalize<TName>}Item`];
+        args: {
+            values: {
+                type: GraphQLNonNull<TInputs[`${Capitalize<TName>}InsertInput`]>;
+            };
+            onConflict: {
+                type: GraphQLInputObjectType;
+            };
+        };
+        resolve: UpsertResolver<TSchemaTables[TName], IsReturnless>;
+    } : never;
 } & {
     [TName in keyof TSchemaTables as TName extends string ? `update${Capitalize<TName>}` : never]: TName extends string ? {
         type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[`${Capitalize<TName>}Item`]>>>;
@@ -191,7 +344,7 @@ type MutationsCore<TSchemaTables extends Record<string, Table>, TInputs extends
         resolve: UpdateResolver<TSchemaTables[TName], IsReturnless>;
     } : never;
 } & {
-    [TName in keyof TSchemaTables as TName extends string ? `deleteFrom${Capitalize<TName>}` : never]: TName extends string ? {
+    [TName in keyof TSchemaTables as TName extends string ? `delete${Capitalize<TName>}` : never]: TName extends string ? {
         type: IsReturnless extends true ? TOutputs['MutationReturn'] extends GraphQLObjectType ? TOutputs['MutationReturn'] : never : GraphQLNonNull<GraphQLList<GraphQLNonNull<TOutputs[`${Capitalize<TName>}Item`]>>>;
         args: {
             where: {
@@ -212,6 +365,8 @@ type GeneratedInputs<TSchema extends Record<string, Table>> = {
 };
 type GeneratedOutputs<TSchema extends Record<string, Table>, IsReturnless extends boolean> = {
     [TName in keyof TSchema as TName extends string ? `${Capitalize<TName>}SelectItem` : never]: GraphQLObjectType;
+} & {
+    [TName in keyof TSchema as TName extends string ? `${Capitalize<TName>}Aggregate` : never]: GraphQLObjectType;
 } & (IsReturnless extends true ? {
     MutationReturn: GraphQLObjectType;
 } : {
@@ -222,11 +377,46 @@ type GeneratedEntities<TDatabase extends AnyDrizzleDB<TSchema>, TSchema extends
     mutations: MutationsCore<TSchemaTables, TInputs, TOutputs, TDatabase extends MySqlDatabase<any, any, any, any> ? true : false>;
     inputs: TInputs;
     types: TOutputs;
+    /**
+     * Field-level resolvers for each relation on each table.
+     * Each resolver handles both the eager path (data pre-fetched by the parent query)
+     * and the lazy path (data fetched on demand with N+1 protection via request-scoped batching).
+     * Keyed as `fieldResolvers[tableSchemaKey][relationName]`.
+     */
+    fieldResolvers: {
+        [TName in keyof TSchemaTables as TName extends string ? TName : never]?: Record<string, (source: any, args: any, context: any, info: GraphQLResolveInfo) => Promise<any>>;
+    };
 };
 type GeneratedData<TDatabase extends AnyDrizzleDB<any>> = {
     schema: GraphQLSchema;
     entities: GeneratedEntities<TDatabase>;
 };
+/**
+ * Per-feature switches for what `buildSchema` generates. Every flag defaults to `true`.
+ * See {@link BuildSchemaConfig.features}.
+ */
+type SchemaFeatures = {
+    /** `<plural>Aggregate` root queries and the aggregate output types. @default true */
+    aggregates?: boolean;
+    /** `<relation>Aggregate` fields on object types, for to-many relations. @default true */
+    relationAggregates?: boolean;
+    /** The `distinct` argument on list queries. @default true */
+    distinct?: boolean;
+    /** `create<Table>` / `create<Table>Single` mutations. @default true */
+    insert?: boolean;
+    /** `update<Table>` mutations. @default true */
+    update?: boolean;
+    /** `delete<Table>` mutations. @default true */
+    delete?: boolean;
+    /**
+     * `upsert<Table>` / `upsert<Table>Single` mutations — insert, or update the row that
+     * already holds the same unique key. Off unless asked for, so an existing schema does
+     * not grow new mutations on upgrade.
+     *
+     * @default false
+     */
+    upsert?: boolean;
+};
 type BuildSchemaConfig = {
     /**
      * Determines whether generated mutations will be passed to returned schema.
@@ -237,29 +427,39 @@ type BuildSchemaConfig = {
      */
     mutations?: boolean;
     /**
-     * Limits depth of generated relation fields on queries.
+     * Limits depth of relation-field generation.
      *
-     * Expects non-negative integer or undefined.
+     * Expects a non-negative integer or `undefined`.
      *
-     * Set value to `undefined` to not limit relation depth.
+     * `undefined` (default) — no limit; all relations are generated recursively
+     * until a cycle is detected.
      *
-     * Set value to `0` to omit relations altogether.
+     * `0` — no relation fields are generated on any type. Useful for a flat,
+     * columns-only schema.
      *
-     * Value is treated as if set to `undefined` by default.
+     * `N > 0` — each table's own direct relations are still generated (every
+     * table's root type is processed at depth 0, which is always < N). The
+     * depth limit controls how deep the generation RECURSES when traversing
+     * related types; because all types share a single instance via the type
+     * cache, setting N > 0 currently behaves the same as `undefined` for the
+     * final schema shape. The principal useful values are `0` (no relations)
+     * and `undefined` (unlimited).
      */
     relationsDepthLimit?: number;
     /**
      * Customizes query name prefixes for generated GraphQL operations.
      *
-     * @default { list: '', single: 'Single' }
+     * @default { insert: 'create', delete: 'delete', update: 'update', upsert: 'upsert' }
      */
     prefixes?: {
-        /** Prefix for insert mutations (e.g., 'users' -> 'insertIntoUsers') */
+        /** Prefix for insert mutations (e.g., 'users' -> 'createUsers') */
         insert?: string;
-        /** Prefix for delete mutations (e.g., 'users' -> 'deleteFromUsers') */
+        /** Prefix for delete mutations (e.g., 'users' -> 'deleteUsers') */
         delete?: string;
         /** Prefix for update mutations (e.g., 'users' -> 'updateUsers') */
         update?: string;
+        /** Prefix for upsert mutations (e.g., 'users' -> 'upsertUsers') */
+        upsert?: string;
     };
     /**
      * Customizes query name suffixes for generated GraphQL operations.
@@ -275,17 +475,121 @@ type BuildSchemaConfig = {
     /**
      * When true, insert mutations will use onConflictDoNothing() to silently
      * ignore duplicate key violations. Defaults to false (conflicts throw errors).
+     *
+     * PostgreSQL and SQLite only — MySQL's insert builder has no equivalent, so the flag is
+     * ignored there and conflicts keep throwing.
+     *
+     * @deprecated Build-wide and unconditional: a request cannot opt out of it, and a
+     * swallowed insert returns `null` with no indication why. Turn on `features.upsert` and
+     * pass `onConflict: { action: NOTHING }` per request instead. This flag keeps working
+     * until the next major.
      */
     conflictDoNothing?: boolean;
     /**
-     * When true, all generated GraphQL object type names will use the singular form
-     * of the table name (e.g. `users` table → `User` type instead of `Users`).
+     * Turns individual generated features off.
+     *
+     * Every flag defaults to `true` except `upsert`, which is opt-in: a build with no
+     * `features` block generates exactly what it generated before this option existed.
+     * Turning one off removes both the schema surface it adds and the work behind it.
+     *
+     * ```ts
+     * buildSchema(db, {
+     *   features: {
+     *     aggregates: false,         // no `<plural>Aggregate` root queries
+     *     relationAggregates: false, // no `<relation>Aggregate` fields on object types
+     *     distinct: false,           // no `distinct` argument on list queries
+     *     delete: false,             // no delete mutations
+     *     upsert: true,              // opt in to `upsert<Table>` mutations
+     *   },
+     * });
+     * ```
+     *
+     * Turning off every mutation feature omits the `Mutation` type entirely, exactly as
+     * `mutations: false` does. Query-side features can all be off — the list and single
+     * queries are always generated, so `Query` is never empty.
+     */
+    features?: SchemaFeatures;
+    /**
+     * Optional mapper from table key to singular/plural name pair.
+     * When provided for a table, overrides the default (table key) naming for GraphQL type names,
+     * query field names, and mutation field names.
+     * Return `undefined` for tables that should use the default naming.
      *
-     * Defaults to false.
+     * Example: `(name) => name === 'users' ? { singular: 'user', plural: 'users' } : undefined`
+     * produces type `User`, queries `users` / `user`, mutations `createUsers` / `createUser` for
+     * the `users` table, and leaves other tables with their default names.
      */
-    singularTypes?: boolean;
+    typeNameMapper?: (tableName: string) => {
+        singular: string;
+        plural: string;
+    } | undefined;
+    /**
+     * Controls whether a relation is eagerly pre-fetched via Drizzle's `with:` clause
+     * when its parent is loaded through a generated query or mutation.
+     *
+     * `true` (default) — every selected relation is eager-loaded in the parent's query.
+     *
+     * `false` — no relation is ever eager-loaded; all relations resolve lazily through
+     * their (request-batched) field resolvers.
+     *
+     * `(tableName, relationName) => boolean` — decide per relation. Return `false` to
+     * exclude that relation from `with:` (and from the mutation eager re-fetch).
+     *
+     * Opting a relation out does NOT remove its field resolver — it still resolves
+     * lazily via the request-scoped batch loader. This is the hook for overriding a
+     * relation's resolver (e.g. via `@graphql-tools/schema`'s `addResolversToSchema`)
+     * without the eager `with:` query also fetching it from the database:
+     *
+     * ```ts
+     * const { schema } = buildSchema(db, {
+     *   eagerLoadRelations: (t, r) => !(t === 'Users' && r === 'posts'),
+     * });
+     * const finalSchema = addResolversToSchema({
+     *   schema,
+     *   resolvers: { Users: { posts: (parent) => myLoader.load(parent.id) } },
+     * });
+     * ```
+     *
+     * Table and relation names are the Drizzle schema keys (e.g. `Users`, `posts`),
+     * matching the keys of `entities.fieldResolvers`.
+     *
+     * @default true
+     */
+    eagerLoadRelations?: boolean | ((tableName: string, relationName: string) => boolean);
+    /**
+     * Called for every error thrown by a generated resolver, before it reaches the client.
+     *
+     * Return an error to surface that one instead. Return nothing to fall through to the
+     * default handling, which makes this a pure logging hook:
+     *
+     * ```ts
+     * buildSchema(db, { onError: (error) => { logger.error(error) } })
+     * ```
+     *
+     * The default passes through errors drizzle-graphql raises itself (bad filter, missing
+     * values, invalid date, …) and replaces everything else — driver and database errors —
+     * with a generic `Internal server error`, keeping the original on `originalError` so it
+     * is still available to server-side logging. Database messages routinely name tables,
+     * columns, constraints and the values that violated them, which is not something a
+     * public API should hand back.
+     *
+     * To surface raw database errors instead (useful in development):
+     *
+     * ```ts
+     * buildSchema(db, { onError: (error) => error as Error })
+     * ```
+     */
+    onError?: (error: unknown) => unknown;
 };
 
+/**
+ * A 64-bit integer. Always transported as a decimal string, in both directions, so no value
+ * is ever silently rounded by JSON's double-precision numbers. `graphql-scalars`' own
+ * `GraphQLBigInt` is deliberately not used: it emits numbers for safe integers and strings
+ * for everything else, so a client cannot know which it will get.
+ */
+declare const GraphQLBigIntString: GraphQLScalarType<string, string>;
+
 declare const buildSchema: <TDbClient extends AnyDrizzleDB<any>>(db: TDbClient, config?: BuildSchemaConfig) => GeneratedData<TDbClient>;
 
-export { type AnyDrizzleDB, type BuildSchemaConfig, type DeleteResolver, type ExtractRelations, type ExtractTableByName, type ExtractTableRelations, type ExtractTables, type GeneratedData, type GeneratedEntities, type GeneratedInputs, type GeneratedOutputs, type InsertArrResolver, type InsertResolver, type MutationReturnlessResult, type MutationsCore, type QueriesCore, type SelectResolver, type SelectSingleResolver, type UpdateResolver, buildSchema, extractFilters, extractOrderBy };
+export { type AggregateResolver, type AnyDrizzleDB, type BuildSchemaConfig, type DeleteResolver, type ExtractRelations, type ExtractTableByName, type ExtractTableRelations, type ExtractTables, type GeneratedData, type GeneratedEntities, type GeneratedInputs, type GeneratedOutputs, GraphQLBigIntString, type InsertArrResolver, type InsertResolver, type MutationReturnlessResult, type MutationsCore, type QueriesCore, type RelationResolverFactory, type SchemaFeatures, type SelectResolver, type SelectSingleResolver, type TableNamedRelations, type UpdateResolver, type UpsertArgs, type UpsertArrResolver, type UpsertConflictArgs, type UpsertResolver, buildSchema, createRelationResolverFactory, defaultErrorMapper, drizzleExecutorKey, extractFilters, extractOrderBy, extractRelationJoinColumns };