@pothos/plugin-drizzle 0.0.1 → 0.1.0

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,40 +35,13 @@ 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';
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export interface DrizzlePluginOptions<Types extends SchemaTypes> {
+export interface DrizzlePluginOptions<_Types extends SchemaTypes> {
   client: { _: Partial<RelationalSchemaConfig<TablesRelationalConfig>>; query: {} };
   maxConnectionSize?: number;
   defaultConnectionSize?: number;
@@ -238,6 +237,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 +338,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 +349,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 +369,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 +468,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 +511,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 +535,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 +576,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,5 +1,9 @@
-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';
 
 export interface PothosDrizzleSchemaConfig extends RelationalSchemaConfig<TablesRelationalConfig> {
   dbToSchema: Record<string, TableRelationalConfig>;

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>)!);

package/src/utils/loader-map.ts

@@ -1,5 +1,5 @@
-import { GraphQLResolveInfo } from 'graphql';
 import { createContextCache } from '@pothos/core';
+import type { GraphQLResolveInfo } from 'graphql';
 
 export type LoaderMappings = Record<
   string,
@@ -11,7 +11,7 @@ export type LoaderMappings = Record<
   }
 >;
 
-const cache = createContextCache((ctx) => new Map<string, LoaderMappings>());
+const cache = createContextCache(() => new Map<string, LoaderMappings>());
 
 export function cacheKey(type: string, path: GraphQLResolveInfo['path'], subPath: string[] = []) {
   let key = '';
@@ -32,15 +32,13 @@ export function cacheKey(type: string, path: GraphQLResolveInfo['path'], subPath
 }
 
 export function setLoaderMappings(ctx: object, info: GraphQLResolveInfo, value: LoaderMappings) {
-  Object.keys(value).forEach((field) => {
-    const map = cache(ctx);
-
-    const mapping = value[field];
+  const map = cache(ctx);
+  for (const [field, mapping] of Object.entries(value)) {
     const subPath = [...mapping.indirectPath, field];
     const key = cacheKey(mapping.type, info.path, subPath);
 
     map.set(key, mapping.mappings);
-  });
+  }
 }
 
 export function getLoaderMapping(ctx: object, path: GraphQLResolveInfo['path'], type: string) {

package/src/utils/map-query.ts

@@ -1,42 +1,41 @@
-/* eslint-disable no-continue */
+import { PothosValidationError } from '@pothos/core';
 import {
-  DBQueryConfig,
+  type DBQueryConfig,
   RelationalSchemaConfig,
-  TableRelationalConfig,
+  type TableRelationalConfig,
   TablesRelationalConfig,
 } from 'drizzle-orm';
 import {
-  FieldNode,
-  FragmentDefinitionNode,
+  type FieldNode,
+  type FragmentDefinitionNode,
+  type GraphQLField,
+  GraphQLIncludeDirective,
+  type GraphQLInterfaceType,
+  type GraphQLNamedType,
+  type GraphQLObjectType,
+  type GraphQLResolveInfo,
+  GraphQLSkipDirective,
+  type InlineFragmentNode,
+  Kind,
+  type SelectionSetNode,
   getArgumentValues,
   getDirectiveValues,
   getNamedType,
-  GraphQLField,
-  GraphQLIncludeDirective,
-  GraphQLInterfaceType,
-  GraphQLNamedType,
-  GraphQLObjectType,
-  GraphQLResolveInfo,
-  GraphQLSkipDirective,
-  InlineFragmentNode,
   isInterfaceType,
   isObjectType,
-  Kind,
-  SelectionSetNode,
 } from 'graphql';
-import { PothosValidationError } from '@pothos/core';
-import { type DrizzleFieldSelection } from '../types';
-import { LoaderMappings, setLoaderMappings } from './loader-map';
+import type { DrizzleFieldSelection } from '../types';
+import type { PothosDrizzleSchemaConfig } from './config';
+import { type LoaderMappings, setLoaderMappings } from './loader-map';
 import {
+  type SelectionMap,
+  type SelectionState,
   createState,
   mergeSelection,
   selectionCompatible,
-  SelectionMap,
-  SelectionState,
   selectionToQuery,
 } from './selections';
 import { wrapWithUsageCheck } from './usage';
-import { PothosDrizzleSchemaConfig } from './config';
 
 export interface IndirectInclude {
   getType: () => string;
@@ -348,7 +347,6 @@ function addFieldSelection(
           );
         }
         addTypeSelectionsForField(config, returnType, context, info, fieldState, selection, []);
-        // eslint-disable-next-line prefer-destructuring
         mappings = fieldState.mappings;
         return selectionToQuery(fieldState);
       },
@@ -376,7 +374,6 @@ function addFieldSelection(
 
   if (fieldSelect && selectionCompatible(state, fieldSelectionMap, true)) {
     mergeSelection(config, state, fieldSelectionMap);
-    // eslint-disable-next-line no-param-reassign
     state.mappings[selection.alias?.value ?? selection.name.value] = {
       field: selection.name.value,
       type: type.name,

package/src/utils/refs.ts

@@ -1,5 +1,5 @@
-import { SchemaTypes } from '@pothos/core';
-import { DrizzleInterfaceRef, DrizzleRef } from '../interface-ref';
+import type { SchemaTypes } from '@pothos/core';
+import { DrizzleInterfaceRef, type DrizzleRef } from '../interface-ref';
 import { DrizzleObjectRef } from '../object-ref';
 
 export const refMap = new WeakMap<object, Map<string, DrizzleRef<never>>>();

package/src/utils/selections.ts

@@ -1,16 +1,15 @@
-/* eslint-disable no-param-reassign */
+import { PothosValidationError } from '@pothos/core';
 import {
-  DBQueryConfig,
+  type DBQueryConfig,
   RelationalSchemaConfig,
-  SQL,
-  TableRelationalConfig,
+  type SQL,
+  type TableRelationalConfig,
   TablesRelationalConfig,
   getOperators,
 } from 'drizzle-orm';
-import { PothosValidationError } from '@pothos/core';
+import type { PothosDrizzleSchemaConfig } from './config';
 import { deepEqual } from './deep-equal';
-import { LoaderMappings } from './loader-map';
-import { PothosDrizzleSchemaConfig } from './config';
+import type { LoaderMappings } from './loader-map';
 
 export interface SelectionState {
   table: TableRelationalConfig;
@@ -123,7 +122,7 @@ export function mergeSelection(
   { with: withSelection, extras, columns, ...query }: SelectionMap,
 ) {
   if (withSelection) {
-    Object.entries(withSelection).forEach(([key, value]) => {
+    for (const [key, value] of Object.entries(withSelection)) {
       const relation = state.table.relations[key];
 
       if (!relation) {
@@ -131,7 +130,7 @@ export function mergeSelection(
       }
 
       merge(config.dbToSchema[relation.referencedTableName], key, value as SelectionMap | boolean);
-    });
+    }
   }
 
   if (Object.keys(query).length > 0) {

package/src/utils/usage.ts

@@ -20,7 +20,6 @@ export function wrapWithUsageCheck<T extends Object>(obj: T): T {
     Object.defineProperty(result, key, {
       enumerable: true,
       configurable: true,
-      // eslint-disable-next-line @typescript-eslint/no-loop-func
       get() {
         used = true;
         return obj[key as keyof T];
@@ -47,7 +46,6 @@ export function extendWithUsage<T extends object, U extends object>(
 
   for (const key of [usageSymbol, ...Object.keys(original)]) {
     if (key in result) {
-      // eslint-disable-next-line no-continue
       continue;
     }