@pothos/plugin-drizzle 0.0.1 → 0.2.0

package/src/schema-builder.ts

@@ -1,23 +1,24 @@
 import SchemaBuilder, {
   brandWithType,
   completeValue,
-  InterfaceRef,
-  ObjectRef,
-  OutputType,
+  type InterfaceRef,
+  type ObjectRef,
+  type OutputType,
   PothosError,
-  SchemaTypes,
-  FieldRef,
-  InputObjectRef,
+  type SchemaTypes,
+  type FieldRef,
+  type InputObjectRef,
 } from '@pothos/core';
+import type { GraphQLInputObjectType, GraphQLResolveInfo } from 'graphql';
 import { DrizzleObjectFieldBuilder } from './drizzle-field-builder';
-import { getRefFromModel } from './utils/refs';
+import { DrizzleInterfaceRef } from './interface-ref';
+import { ModelLoader } from './model-loader';
+import { DrizzleNodeRef } from './node-ref';
 import { DrizzleObjectRef } from './object-ref';
-import { DrizzleGraphQLInputExtensions, DrizzleNodeOptions } from './types';
+import type { DrizzleGraphQLInputExtensions, DrizzleNodeOptions } from './types';
+import { getSchemaConfig } from './utils/config';
 import { getColumnParser, getColumnSerializer } from './utils/cursors';
-import { DrizzleNodeRef } from './node-ref';
-import { GraphQLInputObjectType, GraphQLResolveInfo } from 'graphql';
-import { ModelLoader } from './model-loader';
-import { DrizzleInterfaceRef } from './interface-ref';
+import { getRefFromModel } from './utils/refs';
 
 const schemaBuilderProto = SchemaBuilder.prototype as PothosSchemaTypes.SchemaBuilder<SchemaTypes>;
 
@@ -35,7 +36,7 @@ schemaBuilderProto.drizzleObject = function drizzleObject(table, { select, field
     extensions: {
       ...options.extensions,
       pothosDrizzleModel: table,
-      pothosDrizzleTable: this.options.drizzle.client._.schema?.[table],
+      pothosDrizzleTable: getSchemaConfig(this).schema?.[table],
       pothosDrizzleSelect: select ?? {},
       pothosDrizzleLoader: ModelLoader.forModel(table, this),
     },
@@ -63,7 +64,7 @@ schemaBuilderProto.drizzleInterface = function drizzleInterface(
     extensions: {
       ...options.extensions,
       pothosDrizzleModel: table,
-      pothosDrizzleTable: this.options.drizzle.client._.schema?.[table],
+      pothosDrizzleTable: getSchemaConfig(this).schema?.[table],
       pothosDrizzleSelect: select ?? {},
       pothosDrizzleLoader: ModelLoader.forModel(table, this),
     },
@@ -88,7 +89,7 @@ schemaBuilderProto.drizzleNode = function drizzleNode(
     ...options
   }: DrizzleNodeOptions<SchemaTypes, keyof SchemaTypes['DrizzleRelationSchema'], {}, {}, []>,
 ) {
-  const tableConfig = this.options.drizzle.client._.schema![table];
+  const tableConfig = getSchemaConfig(this).schema![table];
   const idColumn = typeof column === 'function' ? column(tableConfig.columns) : column;
   const idColumns = Array.isArray(idColumn) ? idColumn : [idColumn];
   const interfaceRef = this.nodeInterfaceRef?.();
@@ -139,12 +140,12 @@ schemaBuilderProto.drizzleNode = function drizzleNode(
             globalID: (options: Record<string, unknown>) => FieldRef<SchemaTypes, unknown>;
           }
         ).globalID({
-          ...(this.options as { relayOptions?: { idFieldOptions?: {} } }).relayOptions
+          ...(this.options as { relayOptions?: { idFieldOptions?: object } }).relayOptions
             ?.idFieldOptions,
           ...idOptions,
           nullable: false,
           args: {},
-          resolve: (parent: never, args: object, context: object, info: GraphQLResolveInfo) =>
+          resolve: (parent: never) =>
             completeValue(resolve(parent), (id) => ({
               type: nodeConfig.name,
               id,
@@ -198,7 +199,7 @@ schemaBuilderProto.drizzleGraphQLOrderBy = function drizzleGraphQLOrderBy(
   this: PothosSchemaTypes.SchemaBuilder<SchemaTypes>,
   table: string,
   type: GraphQLInputObjectType,
-  options?: { extensions?: {} },
+  options?: { extensions?: object },
 ) {
   return (
     this as typeof this & {
@@ -214,7 +215,7 @@ schemaBuilderProto.drizzleGraphQLOrderBy = function drizzleGraphQLOrderBy(
       drizzleGraphQL: {
         inputType: 'orderBy',
         table,
-        tableConfig: this.options.drizzle.client._.schema?.[table]!,
+        tableConfig: getSchemaConfig(this).schema?.[table]!,
       } satisfies DrizzleGraphQLInputExtensions,
     },
   });
@@ -224,7 +225,7 @@ schemaBuilderProto.drizzleGraphQLFilters = function drizzleGraphQLFilters(
   this: PothosSchemaTypes.SchemaBuilder<SchemaTypes>,
   table: string,
   type: GraphQLInputObjectType,
-  options?: { extensions?: {} },
+  options?: { extensions?: object },
 ) {
   return (
     this as typeof this & {
@@ -240,7 +241,7 @@ schemaBuilderProto.drizzleGraphQLFilters = function drizzleGraphQLFilters(
       drizzleGraphQL: {
         inputType: 'filters',
         table,
-        tableConfig: this.options.drizzle.client._.schema?.[table]!,
+        tableConfig: getSchemaConfig(this).schema?.[table]!,
       } satisfies DrizzleGraphQLInputExtensions,
     },
   });
@@ -250,7 +251,7 @@ schemaBuilderProto.drizzleGraphQLInsert = function drizzleGraphQLInsert(
   this: PothosSchemaTypes.SchemaBuilder<SchemaTypes>,
   table: string,
   type: GraphQLInputObjectType,
-  options?: { extensions?: {} },
+  options?: { extensions?: object },
 ) {
   return (
     this as typeof this & {
@@ -266,7 +267,7 @@ schemaBuilderProto.drizzleGraphQLInsert = function drizzleGraphQLInsert(
       drizzleGraphQL: {
         inputType: 'insert',
         table,
-        tableConfig: this.options.drizzle.client._.schema?.[table]!,
+        tableConfig: getSchemaConfig(this).schema?.[table]!,
       } satisfies DrizzleGraphQLInputExtensions,
     },
   });
@@ -276,7 +277,7 @@ schemaBuilderProto.drizzleGraphQLUpdate = function drizzleGraphQLUpdate(
   this: PothosSchemaTypes.SchemaBuilder<SchemaTypes>,
   table: string,
   type: GraphQLInputObjectType,
-  options?: { extensions?: {} },
+  options?: { extensions?: object },
 ) {
   return (
     this as typeof this & {
@@ -292,7 +293,7 @@ schemaBuilderProto.drizzleGraphQLUpdate = function drizzleGraphQLUpdate(
       drizzleGraphQL: {
         inputType: 'update',
         table,
-        tableConfig: this.options.drizzle.client._.schema?.[table]!,
+        tableConfig: getSchemaConfig(this).schema?.[table]!,
       } satisfies DrizzleGraphQLInputExtensions,
     },
   });

package/src/types.ts

@@ -1,4 +1,30 @@
 import {
+  type ArgumentRef,
+  type FieldKind,
+  type FieldMap,
+  type FieldNullability,
+  type FieldOptionsFromKind,
+  type InferredFieldOptionKeys,
+  type InferredFieldOptionsByKind,
+  type InputFieldMap,
+  type InputFieldsFromShape,
+  type InputShapeFromFields,
+  type InterfaceParam,
+  type InterfaceRef,
+  type InterfaceTypeOptions,
+  type ListResolveValue,
+  type MaybePromise,
+  type Normalize,
+  type ObjectRef,
+  type ObjectTypeOptions,
+  type OutputShape,
+  type OutputType,
+  type SchemaTypes,
+  type ShapeFromTypeParam,
+  type TypeParam,
+  typeBrandKey,
+} from '@pothos/core';
+import type {
   BuildQueryResult,
   Column,
   DBQueryConfig,
@@ -9,44 +35,30 @@ import {
   TableRelationalConfig,
   TablesRelationalConfig,
 } from 'drizzle-orm';
-import { FieldNode, GraphQLResolveInfo } from 'graphql';
-import {
-  ArgumentRef,
-  FieldKind,
-  FieldMap,
-  FieldNullability,
-  FieldOptionsFromKind,
-  InferredFieldOptionKeys,
-  InferredFieldOptionsByKind,
-  InputFieldMap,
-  InputFieldsFromShape,
-  InputShapeFromFields,
-  InterfaceParam,
-  InterfaceRef,
-  InterfaceTypeOptions,
-  ListResolveValue,
-  MaybePromise,
-  Normalize,
-  ObjectRef,
-  ObjectTypeOptions,
-  OutputShape,
-  OutputType,
-  SchemaTypes,
-  ShapeFromTypeParam,
-  typeBrandKey,
-  TypeParam,
-} from '@pothos/core';
+import type { FieldNode, GraphQLResolveInfo } from 'graphql';
 import type { DrizzleObjectFieldBuilder } from './drizzle-field-builder';
-import { type DrizzleRef } from './interface-ref';
-import { IndirectInclude } from './utils/map-query';
-import { SelectionMap } from './utils/selections';
+import type { DrizzleRef } from './interface-ref';
+import type { IndirectInclude } from './utils/map-query';
+import type { SelectionMap } from './utils/selections';
+
+export type DrizzleClient = {
+  _: Partial<RelationalSchemaConfig<TablesRelationalConfig>>;
+  query: {};
+};
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export interface DrizzlePluginOptions<Types extends SchemaTypes> {
-  client: { _: Partial<RelationalSchemaConfig<TablesRelationalConfig>>; query: {} };
+export type DrizzlePluginOptions<Types extends SchemaTypes> = {
   maxConnectionSize?: number;
   defaultConnectionSize?: number;
-}
+} & (
+  | {
+      client: DrizzleClient;
+      schema?: Partial<RelationalSchemaConfig<TablesRelationalConfig>>;
+    }
+  | {
+      client: (ctx: Types['Context']) => DrizzleClient;
+      schema: Partial<RelationalSchemaConfig<TablesRelationalConfig>>;
+    }
+);
 
 export const drizzleTableName = Symbol.for('Pothos.drizzleTableName');
 
@@ -238,6 +250,7 @@ export type DrizzleObjectFieldOptions<
         : BuildQueryResult<
             Types['DrizzleRelationSchema'],
             ExtractTable<Types, ParentShape>,
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
             Record<string, unknown> & (Select extends (...args: any[]) => infer R ? R : Select)
           > &
             ParentShape,
@@ -338,6 +351,7 @@ export type RelatedFieldOptions<
 export type VariantFieldOptions<
   Types extends SchemaTypes,
   Table extends keyof Types['DrizzleRelationSchema'],
+  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
   Variant extends DrizzleRef<any, Table> | Table,
   Args extends InputFieldMap,
   isNull,
@@ -348,6 +362,7 @@ export type VariantFieldOptions<
   FieldOptionsFromKind<
     Types,
     Shape,
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation>
     Variant extends DrizzleRef<any> ? Variant : DrizzleRef<any, Table>,
     unknown extends isNull ? false : true,
     Args,
@@ -367,6 +382,7 @@ export type VariantFieldOptions<
                 Types['DrizzleRelationSchema'],
                 ExtractTable<Types, Shape>,
                 Record<string, unknown> &
+                  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
                   (ResolveShape extends (...args: any[]) => infer R ? R : ResolveShape)
               > &
                 Shape,
@@ -465,16 +481,14 @@ export type ListRelation<T extends TableRelationalConfig> = {
 export type DrizzleConnectionFieldOptions<
   Types extends SchemaTypes,
   ParentShape,
-  Type extends
-    | DrizzleRef<any, keyof Types['DrizzleRelationSchema']>
-    | keyof Types['DrizzleRelationSchema'],
+  Type extends // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+  DrizzleRef<any, keyof Types['DrizzleRelationSchema']> | keyof Types['DrizzleRelationSchema'],
   TableConfig extends TableRelationalConfig,
   Param extends OutputType<Types>,
   Nullable extends boolean,
   Args extends InputFieldMap,
   ResolveReturnShape,
   Kind extends FieldKind,
-  // eslint-disable-next-line @typescript-eslint/sort-type-constituents
 > = Omit<
   FieldOptionsFromKind<
     Types,
@@ -510,15 +524,7 @@ export type DrizzleConnectionFieldOptions<
         maxSize?: number | ((args: ConnectionArgs, ctx: Types['Context']) => number);
 
         resolve: (
-          query: <
-            T extends QueryForRelatedConnection<
-              Types,
-              Types['DrizzleRelationSchema'][Type extends DrizzleRef<any, infer K>
-                ? K
-                : Type & keyof Types['DrizzleRelationSchema']],
-              ConnectionArgs
-            >,
-          >(
+          query: <T extends QueryForRelatedConnection<Types, TableConfig, ConnectionArgs>>(
             selection?: T,
           ) => Omit<T, 'orderBy'> & { orderBy: SQL },
           parent: ParentShape,
@@ -542,7 +548,6 @@ export type RelatedConnectionOptions<
   Args extends InputFieldMap,
   NodeTable extends
     TableRelationalConfig = Types['DrizzleRelationSchema'][Table['relations'][Field]['referencedTable']['_']['name']],
-  // eslint-disable-next-line @typescript-eslint/sort-type-constituents
 > = Omit<
   PothosSchemaTypes.ObjectFieldOptions<
     Types,
@@ -584,6 +589,7 @@ export type RelatedConnectionOptions<
           >
         >;
         query: QueryForRelatedConnection<Types, NodeTable, ConnectionArgs>;
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
         type?: DrizzleRef<any, Table['relations'][Field]['referencedTable']['_']['name']>;
 
         defaultSize?: number | ((args: ConnectionArgs, ctx: Types['Context']) => number);

package/src/utils/config.ts

@@ -1,11 +1,20 @@
-import { createContextCache, SchemaTypes } from '@pothos/core';
-import { RelationalSchemaConfig, TableRelationalConfig, TablesRelationalConfig } from 'drizzle-orm';
+import { type SchemaTypes, createContextCache } from '@pothos/core';
+import type {
+  RelationalSchemaConfig,
+  TableRelationalConfig,
+  TablesRelationalConfig,
+} from 'drizzle-orm';
+import type { DrizzleClient } from '../types';
 
 export interface PothosDrizzleSchemaConfig extends RelationalSchemaConfig<TablesRelationalConfig> {
   dbToSchema: Record<string, TableRelationalConfig>;
 }
-const cache = createContextCache(
-  (config: RelationalSchemaConfig<TablesRelationalConfig>): PothosDrizzleSchemaConfig => {
+const configCache = createContextCache(
+  (builder: PothosSchemaTypes.SchemaBuilder<SchemaTypes>): PothosDrizzleSchemaConfig => {
+    const config = (builder.options.drizzle.schema ??
+      (builder.options.drizzle.client as DrizzleClient)
+        ._) as RelationalSchemaConfig<TablesRelationalConfig>;
+
     const dbToSchema = Object.values(config.schema).reduce<Record<string, TableRelationalConfig>>(
       (acc, table) => {
         acc[table.dbName] = table;
@@ -21,8 +30,29 @@ const cache = createContextCache(
   },
 );
 
+const clientCache = createContextCache((builder: PothosSchemaTypes.SchemaBuilder<SchemaTypes>) => {
+  const clientConfig = builder.options.drizzle.client;
+  const getClient =
+    typeof clientConfig === 'function'
+      ? createContextCache((ctx) => clientConfig(ctx))
+      : (_ctx: object) => clientConfig;
+
+  return createContextCache((context: object) => {
+    const client = getClient(context);
+
+    return client;
+  });
+});
+
 export function getSchemaConfig<Types extends SchemaTypes>(
   builder: PothosSchemaTypes.SchemaBuilder<Types>,
 ) {
-  return cache(builder.options.drizzle.client._ as RelationalSchemaConfig<TablesRelationalConfig>);
+  return configCache(builder as never);
+}
+
+export function getClient<Types extends SchemaTypes>(
+  builder: PothosSchemaTypes.SchemaBuilder<Types>,
+  context: object,
+) {
+  return clientCache(builder as never)(context);
 }

package/src/utils/cursors.ts

@@ -1,25 +1,23 @@
-/* eslint-disable no-nested-ternary */
 import {
+  type MaybePromise,
+  PothosValidationError,
+  type SchemaTypes,
   decodeBase64,
   encodeBase64,
-  MaybePromise,
-  PothosValidationError,
-  SchemaTypes,
 } from '@pothos/core';
 import {
-  Column,
+  type Column,
+  type DBQueryConfig,
+  type SQL,
+  type TableRelationalConfig,
   getOperators,
   getOrderByOperators,
-  RelationalSchemaConfig,
-  SQL,
-  TableRelationalConfig,
-  TablesRelationalConfig,
 } from 'drizzle-orm';
-import { ConnectionOrderBy, QueryForDrizzleConnection } from '../types';
-import { SelectionMap } from './selections';
-import { GraphQLResolveInfo } from 'graphql';
+import type { GraphQLResolveInfo } from 'graphql';
+import type { ConnectionOrderBy, QueryForDrizzleConnection } from '../types';
+import type { PothosDrizzleSchemaConfig } from './config';
 import { queryFromInfo } from './map-query';
-import { PothosDrizzleSchemaConfig } from './config';
+import type { SelectionMap } from './selections';
 
 const DEFAULT_MAX_SIZE = 100;
 const DEFAULT_SIZE = 20;
@@ -224,7 +222,8 @@ function parseOrderBy(orderBy: ConnectionOrderBy, invert: boolean) {
         direction: asc,
         column: field.asc,
       };
-    } else if (typeof field === 'object' && 'desc' in field) {
+    }
+    if (typeof field === 'object' && 'desc' in field) {
       return {
         direction: desc,
         column: field.desc,
@@ -297,11 +296,11 @@ export function drizzleCursorConnectionQuery({
 
   const columns: Record<string, boolean> = {};
 
-  parsedOrderBy.columns.forEach((column) => {
+  for (const column of parsedOrderBy.columns) {
     columns[column.name] = true;
-  });
+  }
 
-  let whereClauses: (SQL | undefined)[] = where ? [where] : [];
+  const whereClauses: (SQL | undefined)[] = where ? [where] : [];
 
   if (cursor) {
     const cursorParser = getCursorParser(parsedOrderBy.columns);
@@ -345,7 +344,7 @@ export function wrapConnectionResult<T extends {}>(
   args: PothosSchemaTypes.DefaultConnectionArguments,
   limit: number,
   cursor: (node: T) => string,
-  resolveNode?: (node: unknown) => unknown,
+  resolveNode?: (node: Record<string, unknown>) => unknown,
 ) {
   const gotFullResults = results.length === Math.abs(limit);
   const hasNextPage = args.before ? true : args.last ? false : gotFullResults;
@@ -365,7 +364,7 @@ export function wrapConnectionResult<T extends {}>(
     },
   };
 
-  const edges = nodes.map((value, index) =>
+  const edges = nodes.map((value) =>
     value == null
       ? null
       : resolveNode
@@ -403,8 +402,8 @@ export async function resolveDrizzleCursorConnection<T extends {}>(
     queryFn: (query: QueryForDrizzleConnection<SchemaTypes, TableRelationalConfig>) => SelectionMap,
   ) => MaybePromise<readonly T[]>,
 ) {
-  let query;
-  let formatter;
+  let query: DBQueryConfig<'many', false>;
+  let formatter: (node: Record<string, unknown>) => string;
   const results = await resolve((q) => {
     const { cursorColumns, ...connectionQuery } = drizzleCursorConnectionQuery({
       ...options,
@@ -442,5 +441,5 @@ export async function resolveDrizzleCursorConnection<T extends {}>(
     return results;
   }
 
-  return wrapConnectionResult(results, options.args, query!.limit, formatter!);
+  return wrapConnectionResult(results, options.args, query!.limit as number, formatter!);
 }

package/src/utils/deep-equal.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-continue */
 export function deepEqual(left: unknown, right: unknown, ignore?: Set<string>) {
   if (left === right) {
     return true;

package/src/utils/drizzle-graphql.ts

@@ -1,12 +1,22 @@
-import { asc, Column, desc, getOperators, SQL, Table, TableRelationalConfig } from 'drizzle-orm';
+import {
+  type Column,
+  type SQL,
+  Table,
+  type TableRelationalConfig,
+  asc,
+  desc,
+  getOperators,
+} from 'drizzle-orm';
 import { GraphQLError } from 'graphql';
 
+// biome-ignore lint/suspicious/noExplicitAny: <explanation>
 export const remapFromGraphQLCore = (value: any, column: Column, columnName: string) => {
   switch (column.dataType) {
     case 'date': {
       const formatted = new Date(value);
-      if (Number.isNaN(formatted.getTime()))
+      if (Number.isNaN(formatted.getTime())) {
         throw new GraphQLError(`Field '${columnName}' is not a valid date!`);
+      }
 
       return formatted;
     }
@@ -20,7 +30,9 @@ export const remapFromGraphQLCore = (value: any, column: Column, columnName: str
     }
 
     case 'json': {
-      if (column.columnType === 'PgGeometryObject') return value;
+      if (column.columnType === 'PgGeometryObject') {
+        return value;
+      }
 
       try {
         return JSON.parse(value);
@@ -48,7 +60,7 @@ export const remapFromGraphQLCore = (value: any, column: Column, columnName: str
     case 'bigint': {
       try {
         return BigInt(value);
-      } catch (error) {
+      } catch (_error) {
         throw new GraphQLError(`Field '${columnName}' is not a BigInt!`);
       }
     }
@@ -60,6 +72,7 @@ export const remapFromGraphQLCore = (value: any, column: Column, columnName: str
 };
 
 export const remapFromGraphQLSingleInput = (
+  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
   queryInput: Record<string, any>,
   table: TableRelationalConfig,
 ) => {
@@ -68,7 +81,9 @@ export const remapFromGraphQLSingleInput = (
       delete queryInput[key];
     } else {
       const column = table.columns[key];
-      if (!column) throw new GraphQLError(`Unknown column: ${key}`);
+      if (!column) {
+        throw new GraphQLError(`Unknown column: ${key}`);
+      }
 
       if (value === null && column.notNull) {
         delete queryInput[key];
@@ -83,10 +98,13 @@ export const remapFromGraphQLSingleInput = (
 };
 
 export const remapFromGraphQLArrayInput = (
+  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
   queryInput: Record<string, any>[],
   table: TableRelationalConfig,
 ) => {
-  for (const entry of queryInput) remapFromGraphQLSingleInput(entry, table);
+  for (const entry of queryInput) {
+    remapFromGraphQLSingleInput(entry, table);
+  }
 
   return queryInput;
 };
@@ -100,6 +118,7 @@ export type OrderByArgs<TTable extends TableRelationalConfig> = {
 
 export const extractOrderBy = <
   TTable extends TableRelationalConfig,
+  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
   TArgs extends OrderByArgs<any> = OrderByArgs<TTable>,
 >(
   table: TTable,
@@ -110,7 +129,9 @@ export const extractOrderBy = <
   for (const [column, config] of Object.entries(orderArgs).sort(
     (a, b) => (b[1]?.priority ?? 0) - (a[1]?.priority ?? 0),
   )) {
-    if (!config) continue;
+    if (!config) {
+      continue;
+    }
     const { direction } = config;
 
     res.push(direction === 'asc' ? asc(table.columns[column]!) : desc(table.columns[column]!));
@@ -126,7 +147,10 @@ export const extractFiltersColumn = <TColumn extends Column>(
   columnName: string,
   operators: Record<string, unknown> & { OR?: Record<string, unknown>[] },
 ): SQL | undefined => {
-  if (!operators.OR?.length) delete operators.OR;
+  if (!operators.OR?.length) {
+    // biome-ignore lint/performance/noDelete: <explanation>
+    delete operators.OR;
+  }
 
   const entries = Object.entries(operators);
 
@@ -142,6 +166,7 @@ export const extractFiltersColumn = <TColumn extends Column>(
     for (const variant of operators.OR) {
       const extracted = extractFiltersColumn(column, columnName, variant);
 
+      // biome-ignore lint/style/useBlockStatements: <explanation>
       if (extracted) variants.push(extracted);
     }
 
@@ -150,6 +175,7 @@ export const extractFiltersColumn = <TColumn extends Column>(
 
   const variants = [] as SQL[];
   for (const [operatorName, operatorValue] of entries) {
+    // biome-ignore lint/style/useBlockStatements: <explanation>
     if (operatorValue === null || operatorValue === false) continue;
 
     switch (operatorName) {
@@ -158,11 +184,12 @@ export const extractFiltersColumn = <TColumn extends Column>(
       case 'gt':
       case 'gte':
       case 'lt':
-      case 'lte':
+      case 'lte': {
         const singleValue = remapFromGraphQLCore(operatorValue, column, columnName);
         variants.push(ops[operatorName](column, singleValue));
 
         break;
+      }
       case 'like':
       case 'notLike':
       case 'ilike':
@@ -170,18 +197,21 @@ export const extractFiltersColumn = <TColumn extends Column>(
         variants.push(ops[operatorName](column, operatorValue as string));
         break;
       case 'inArray':
-      case 'notInArray':
+      case 'notInArray': {
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
         if (!(operatorValue as any[]).length) {
           throw new GraphQLError(
             `WHERE ${columnName}: Unable to use operator ${operatorName} with an empty array!`,
           );
         }
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
         const arrayValue = (operatorValue as any[]).map((val) =>
           remapFromGraphQLCore(val, column, columnName),
         );
 
         variants.push(ops[operatorName](column, arrayValue));
         break;
+      }
       case 'isNull':
       case 'isNotNull':
         variants.push(ops[operatorName](column));
@@ -201,10 +231,15 @@ export const extractFilters = <TTable extends TableRelationalConfig>(
     OR?: Record<string, unknown>[];
   },
 ): SQL | undefined => {
-  if (!filters.OR?.length) delete filters.OR;
+  if (!filters.OR?.length) {
+    // biome-ignore lint/performance/noDelete: <explanation>
+    delete filters.OR;
+  }
 
   const entries = Object.entries(filters);
-  if (!entries.length) return;
+  if (!entries.length) {
+    return;
+  }
 
   if (filters.OR) {
     if (entries.length > 1) {
@@ -217,7 +252,9 @@ export const extractFilters = <TTable extends TableRelationalConfig>(
 
     for (const variant of filters.OR) {
       const extracted = extractFilters(table, tableName, variant);
-      if (extracted) variants.push(extracted);
+      if (extracted) {
+        variants.push(extracted);
+      }
     }
 
     return variants.length ? (variants.length > 1 ? ops.or(...variants) : variants[0]) : undefined;
@@ -225,7 +262,9 @@ export const extractFilters = <TTable extends TableRelationalConfig>(
 
   const variants = [] as SQL[];
   for (const [columnName, operators] of entries) {
-    if (operators === null) continue;
+    if (operators === null) {
+      continue;
+    }
 
     const column = table.columns[columnName]!;
     variants.push(extractFiltersColumn(column, columnName, operators as Record<string, unknown>)!);