@pothos/plugin-drizzle 0.0.1 → 0.2.0

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;
     }