@pothos/plugin-drizzle 0.0.1 → 0.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pothos/plugin-drizzle",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "A Pothos plugin for drizzle",
   "main": "./lib/index.js",
   "types": "./dts/index.d.ts",
@@ -35,23 +35,23 @@
   },
   "peerDependencies": {
     "@pothos/core": "*",
-    "graphql": "^16.8.1"
+    "graphql": ">=16.6.0"
   },
   "devDependencies": {
-    "@libsql/client": "^0.7.0",
+    "@libsql/client": "^0.8.0",
     "drizzle-graphql": "^0.8.4",
-    "drizzle-kit": "^0.23.0",
-    "drizzle-orm": "^0.32.0",
+    "drizzle-kit": "^0.23.1",
+    "drizzle-orm": "^0.32.1",
     "graphql": "^16.8.1",
     "graphql-scalars": "^1.23.0",
     "graphql-tag": "^2.12.6",
     "postgres": "^3.4.4",
-    "@pothos/core": "4.0.2",
-    "@pothos/plugin-add-graphql": "4.0.2",
-    "@pothos/plugin-relay": "4.0.2",
-    "@pothos/plugin-scope-auth": "4.0.2",
-    "@pothos/plugin-with-input": "4.0.2",
-    "@pothos/test-utils": "2.0.1"
+    "@pothos/plugin-add-graphql": "4.1.0",
+    "@pothos/core": "4.1.0",
+    "@pothos/plugin-relay": "4.1.0",
+    "@pothos/plugin-scope-auth": "4.1.0",
+    "@pothos/plugin-with-input": "4.1.0",
+    "@pothos/test-utils": "2.1.0"
   },
   "scripts": {
     "type": "tsc --project tsconfig.type.json",

package/src/drizzle-field-builder.ts

@@ -1,23 +1,29 @@
-import { getOperators, InferModelFromColumns, Many, TableRelationalConfig } from 'drizzle-orm';
 import {
-  CompatibleTypes,
-  ExposeNullability,
-  FieldKind,
-  FieldRef,
-  InputFieldMap,
-  InterfaceParam,
-  isThenable,
-  MaybePromise,
-  NormalizeArgs,
+  type CompatibleTypes,
+  type ExposeNullability,
+  type FieldKind,
+  type FieldRef,
+  type InputFieldMap,
+  type InterfaceParam,
+  type MaybePromise,
+  type NormalizeArgs,
   ObjectRef,
-  PluginName,
+  type PluginName,
   PothosSchemaError,
   RootFieldBuilder,
-  SchemaTypes,
-  ShapeFromTypeParam,
-  TypeParam,
+  type SchemaTypes,
+  type ShapeFromTypeParam,
+  type TypeParam,
+  isThenable,
 } from '@pothos/core';
 import {
+  type InferModelFromColumns,
+  Many,
+  type TableRelationalConfig,
+  getOperators,
+} from 'drizzle-orm';
+import type { DrizzleRef } from './interface-ref';
+import type {
   DrizzleConnectionShape,
   ListRelation,
   RelatedConnectionOptions,
@@ -26,18 +32,16 @@ import {
   TypesForRelation,
   VariantFieldOptions,
 } from './types';
-import { getRefFromModel } from './utils/refs';
 import {
   drizzleCursorConnectionQuery,
   getCursorFormatter,
   wrapConnectionResult,
 } from './utils/cursors';
-import { SelectionMap } from './utils/selections';
-import { DrizzleRef } from './interface-ref';
+import { getRefFromModel } from './utils/refs';
+import type { SelectionMap } from './utils/selections';
 
 // Workaround for FieldKind not being extended on Builder classes
 const RootBuilder: {
-  // eslint-disable-next-line @typescript-eslint/prefer-function-type
   new <Types extends SchemaTypes, Shape, Kind extends FieldKind>(
     builder: PothosSchemaTypes.SchemaBuilder<Types>,
     kind: FieldKind,
@@ -236,7 +240,7 @@ export class DrizzleObjectFieldBuilder<
     const relationSelect = (
       args: object,
       context: object,
-      nestedQuery: (query: unknown, path?: unknown) => { select?: {} },
+      nestedQuery: (query: unknown, path?: unknown) => { select?: object },
     ) => {
       typeName ??= this.builder.configStore.getTypeConfig(ref).name;
       const nested = nestedQuery(getQuery(args, context).select, {
@@ -326,8 +330,11 @@ export class DrizzleObjectFieldBuilder<
     const ref: DrizzleRef<Types> =
       typeof variant === 'string' ? getRefFromModel(variant, this.builder) : variant;
 
-    const selfSelect = (args: object, context: object, nestedQuery: (query: unknown) => unknown) =>
-      nestedQuery({});
+    const selfSelect = (
+      _args: object,
+      _context: object,
+      nestedQuery: (query: unknown) => unknown,
+    ) => nestedQuery({});
 
     return this.field({
       ...(options as {}),

package/src/field-builder.ts

@@ -1,13 +1,13 @@
-import { GraphQLResolveInfo } from 'graphql';
-import { FieldKind, ObjectRef, RootFieldBuilder, SchemaTypes } from '@pothos/core';
+import { type FieldKind, ObjectRef, RootFieldBuilder, type SchemaTypes } from '@pothos/core';
+import type { FieldRef } from '@pothos/core';
+import type { TableRelationalConfig } from 'drizzle-orm';
+import type { GraphQLResolveInfo } from 'graphql';
+import type { DrizzleRef } from './interface-ref';
+import type { DrizzleConnectionFieldOptions } from './types';
+import { getSchemaConfig } from './utils/config';
+import { resolveDrizzleCursorConnection } from './utils/cursors';
 import { queryFromInfo } from './utils/map-query';
 import { getRefFromModel } from './utils/refs';
-import { FieldRef } from '@pothos/core';
-import { DrizzleRef } from './interface-ref';
-import { DrizzleConnectionFieldOptions } from './types';
-import { TableRelationalConfig } from 'drizzle-orm';
-import { resolveDrizzleCursorConnection } from './utils/cursors';
-import { getSchemaConfig } from './utils/config';
 
 const fieldBuilderProto = RootFieldBuilder.prototype as PothosSchemaTypes.RootFieldBuilder<
   SchemaTypes,
@@ -158,7 +158,7 @@ fieldBuilderProto.drizzleConnection = function drizzleConnection<
       : {
           ...connectionOptions,
           extensions: {
-            ...(connectionOptions as Record<string, {}> | undefined)?.extensions,
+            ...(connectionOptions as Record<string, object> | undefined)?.extensions,
           },
         },
     edgeOptions,

package/src/global-types.ts

@@ -1,13 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-empty-interface */
 import type {
-  BuildQueryResult,
-  DBQueryConfig,
-  ExtractTablesWithRelations,
-  SQL,
-  TableRelationalConfig,
-} from 'drizzle-orm';
-import {
   FieldKind,
   FieldMap,
   FieldNullability,
@@ -21,9 +12,16 @@ import {
   ShapeFromTypeParam,
   TypeParam,
 } from '@pothos/core';
-import { DrizzleObjectFieldBuilder } from './drizzle-field-builder';
-import { DrizzleInterfaceRef, DrizzleRef } from './interface-ref';
-import { DrizzleObjectRef, drizzleTableKey } from './object-ref';
+import type {
+  BuildQueryResult,
+  DBQueryConfig,
+  ExtractTablesWithRelations,
+  SQL,
+  TableRelationalConfig,
+} from 'drizzle-orm';
+import type { DrizzleObjectFieldBuilder } from './drizzle-field-builder';
+import type { DrizzleInterfaceRef, DrizzleRef } from './interface-ref';
+import type { DrizzleObjectRef, drizzleTableKey } from './object-ref';
 import type {
   AddGraphQLInputTypeOptions,
   DrizzleConnectionFieldOptions,
@@ -35,13 +33,13 @@ import type {
   DrizzleObjectFieldOptions,
   DrizzleObjectOptions,
   DrizzlePluginOptions,
-  drizzleTableName,
   ShapeFromConnection,
+  drizzleTableName,
 } from './types';
 
+import type { GraphQLInputObjectType } from 'graphql';
 import type { PothosDrizzlePlugin } from '.';
-import { DrizzleNodeRef } from './node-ref';
-import { GraphQLInputObjectType } from 'graphql';
+import type { DrizzleNodeRef } from './node-ref';
 
 declare global {
   export namespace PothosSchemaTypes {
@@ -274,7 +272,9 @@ declare global {
         Param extends
           | keyof Types['DrizzleRelationSchema']
           | [keyof Types['DrizzleRelationSchema']]
+          // biome-ignore lint/suspicious/noExplicitAny: <explanation>
           | DrizzleRef<any>
+          // biome-ignore lint/suspicious/noExplicitAny: <explanation>
           | [DrizzleRef<any>],
         Nullable extends FieldNullability<Type>,
         ResolveShape,
@@ -284,9 +284,11 @@ declare global {
           ? Param
           : Param extends [keyof Types['DrizzleRelationSchema']]
             ? Param[0]
-            : Param extends DrizzleRef<any, infer T>
+            : // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+              Param extends DrizzleRef<any, infer T>
               ? T & keyof Types['DrizzleRelationSchema']
-              : Param extends [DrizzleRef<any, infer T>]
+              : // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+                Param extends [DrizzleRef<any, infer T>]
                 ? T & keyof Types['DrizzleRelationSchema']
                 : never,
         Type extends TypeParam<Types> = ObjectRef<
@@ -314,12 +316,13 @@ declare global {
 
       drizzleConnection: 'relay' extends PluginName
         ? <
-            Type extends
+            Type extends // biome-ignore lint/suspicious/noExplicitAny: <explanation>
               | DrizzleRef<any, keyof Types['DrizzleRelationSchema']>
               | keyof Types['DrizzleRelationSchema'],
             Nullable extends boolean,
             ResolveReturnShape,
             Args extends InputFieldMap = {},
+            // biome-ignore lint/suspicious/noExplicitAny: <explanation>
             Shape = Type extends DrizzleRef<any, keyof Types['DrizzleRelationSchema'], infer S>
               ? S
               : BuildQueryResult<
@@ -334,6 +337,7 @@ declare global {
               Types,
               ParentShape,
               Type,
+              // biome-ignore lint/suspicious/noExplicitAny: <explanation>
               Types['DrizzleRelationSchema'][Type extends DrizzleRef<any, infer K>
                 ? K
                 : Type & keyof Types['DrizzleRelationSchema']],
@@ -386,7 +390,9 @@ declare global {
             Param extends
               | keyof Types['DrizzleRelationSchema']
               | [keyof Types['DrizzleRelationSchema']]
+              // biome-ignore lint/suspicious/noExplicitAny: <explanation>
               | DrizzleRef<any>
+              // biome-ignore lint/suspicious/noExplicitAny: <explanation>
               | [DrizzleRef<any>],
             Nullable extends FieldNullability<Type>,
             ResolveShape,
@@ -398,9 +404,11 @@ declare global {
               ? Param
               : Param extends [keyof Types['DrizzleRelationSchema']]
                 ? Param[0]
-                : Param extends DrizzleRef<any, infer T>
+                : // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+                  Param extends DrizzleRef<any, infer T>
                   ? T & keyof Types['DrizzleRelationSchema']
-                  : Param extends [DrizzleRef<any, infer T>]
+                  : // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+                    Param extends [DrizzleRef<any, infer T>]
                     ? T & keyof Types['DrizzleRelationSchema']
                     : never,
             Type extends TypeParam<Types> = ObjectRef<

package/src/index.ts

@@ -1,17 +1,16 @@
 import './global-types';
 import './field-builder';
 import './schema-builder';
-import { GraphQLFieldResolver } from 'graphql';
 import SchemaBuilder, {
   BasePlugin,
   createInputValueMapper,
   mapInputFields,
-  PartialResolveInfo,
-  PothosOutputFieldConfig,
-  SchemaTypes,
+  type PothosOutputFieldConfig,
+  type SchemaTypes,
 } from '@pothos/core';
-import { ModelLoader } from './model-loader';
-import { DrizzleGraphQLInputExtensions } from './types';
+import type { GraphQLFieldResolver } from 'graphql';
+import type { ModelLoader } from './model-loader';
+import type { DrizzleGraphQLInputExtensions } from './types';
 import {
   extractFilters,
   extractOrderBy,
@@ -44,37 +43,31 @@ export class PothosDrizzlePlugin<Types extends SchemaTypes> extends BasePlugin<T
     );
 
     const argMapper = argMappings
-      ? createInputValueMapper(
-          argMappings,
-          (input, mappings, ctx: Types['Context'], info: PartialResolveInfo) => {
-            if (!mappings.value) {
-              return input;
-            }
-
-            const { table, tableConfig, inputType } = mappings.value;
-
-            switch (inputType) {
-              case 'orderBy':
-                return extractOrderBy(tableConfig, input as never);
-              case 'filters':
-                return extractFilters(tableConfig, table, input as never);
-              case 'insert':
-                return remapFromGraphQLSingleInput(input as never, tableConfig);
-              case 'update':
-                return remapFromGraphQLSingleInput(input as never, tableConfig);
-
-              default:
-                throw new Error(`Unknown drizzle input type: ${inputType}`);
-            }
-          },
-        )
+      ? createInputValueMapper(argMappings, (input, mappings) => {
+          if (!mappings.value) {
+            return input;
+          }
+
+          const { table, tableConfig, inputType } = mappings.value;
+
+          switch (inputType) {
+            case 'orderBy':
+              return extractOrderBy(tableConfig, input as never);
+            case 'filters':
+              return extractFilters(tableConfig, table, input as never);
+            case 'insert':
+              return remapFromGraphQLSingleInput(input as never, tableConfig);
+            case 'update':
+              return remapFromGraphQLSingleInput(input as never, tableConfig);
+
+            default:
+              throw new Error(`Unknown drizzle input type: ${inputType}`);
+          }
+        })
       : null;
 
     const argMappers: typeof fieldConfig.argMappers = argMapper
-      ? [
-          ...(fieldConfig.argMappers ?? []),
-          (args, context, info) => argMapper(args, undefined, context, info),
-        ]
+      ? [...(fieldConfig.argMappers ?? []), (args) => argMapper(args, undefined)]
       : fieldConfig.argMappers;
 
     if (fieldConfig.kind === 'DrizzleObject' && fieldConfig.pothosOptions.select) {
@@ -121,12 +114,12 @@ export class PothosDrizzlePlugin<Types extends SchemaTypes> extends BasePlugin<T
     const parentTypes = new Set([fieldConfig.parentType]);
 
     if (parentConfig.kind === 'Interface' || parentConfig.kind === 'Object') {
-      parentConfig.interfaces.forEach((iface) => {
+      for (const iface of parentConfig.interfaces) {
         const interfaceConfig = this.buildCache.getTypeConfig(iface, 'Interface');
         if (interfaceConfig.extensions?.pothosDrizzleModel) {
           parentTypes.add(interfaceConfig.name);
         }
-      });
+      }
     }
 
     const modelLoader = parentConfig.extensions?.pothosDrizzleLoader as ReturnType<

package/src/interface-ref.ts

@@ -1,5 +1,5 @@
-import { InterfaceRef, SchemaTypes } from '@pothos/core';
-import { DrizzleObjectRef, drizzleTableKey } from './object-ref';
+import { InterfaceRef, type SchemaTypes } from '@pothos/core';
+import { type DrizzleObjectRef, drizzleTableKey } from './object-ref';
 
 export type DrizzleRef<
   Types extends SchemaTypes,

package/src/model-loader.ts

@@ -1,23 +1,16 @@
-import { GraphQLResolveInfo } from 'graphql';
-import {
-  Column,
-  inArray,
-  RelationalSchemaConfig,
-  sql,
-  TableRelationalConfig,
-  TablesRelationalConfig,
-} from 'drizzle-orm';
-import { createContextCache, SchemaTypes } from '@pothos/core';
+import { type SchemaTypes, createContextCache } from '@pothos/core';
+import { type Column, type TableRelationalConfig, inArray, sql } from 'drizzle-orm';
+import type { GraphQLResolveInfo } from 'graphql';
+import { type PothosDrizzleSchemaConfig, getSchemaConfig } from './utils/config';
 import { cacheKey, setLoaderMappings } from './utils/loader-map';
 import { selectionStateFromInfo, stateFromInfo } from './utils/map-query';
 import {
+  type SelectionMap,
+  type SelectionState,
   mergeSelection,
   selectionCompatible,
-  SelectionMap,
-  SelectionState,
   selectionToQuery,
 } from './utils/selections';
-import { getSchemaConfig, PothosDrizzleSchemaConfig } from './utils/config';
 
 interface ResolvablePromise<T> {
   promise: Promise<T>;
@@ -144,7 +137,7 @@ export class ModelLoader {
     return result;
   }
 
-  async stageQuery(selection: SelectionState, query: SelectionMap, model: object) {
+  stageQuery(selection: SelectionState, query: SelectionMap, model: object) {
     for (const entry of this.staged) {
       if (selectionCompatible(entry.state, query)) {
         mergeSelection(this.config, entry.state, query);
@@ -198,10 +191,11 @@ export class ModelLoader {
 
               if (result) {
                 promise.resolve(result ?? null);
-              } else
+              } else {
                 promise.reject(
                   new Error(`Model ${this.modelName}(${this.sqlForModel(model)}) not found`),
                 );
+              }
             }
           },
           (err) => {
@@ -217,7 +211,7 @@ export class ModelLoader {
         }
       });
 
-    setTimeout(() => void nextTick.resolve(), 0);
+    setTimeout(() => nextTick.resolve(), 0);
 
     return promise.promise;
   }

package/src/node-ref.ts

@@ -1,4 +1,4 @@
-import { SchemaTypes } from '@pothos/core';
+import type { SchemaTypes } from '@pothos/core';
 import { DrizzleObjectRef } from './object-ref';
 
 export class DrizzleNodeRef<

package/src/object-ref.ts

@@ -1,8 +1,8 @@
 import {
+  ObjectRef,
+  type SchemaTypes,
   abstractReturnShapeKey,
   brandWithType,
-  ObjectRef,
-  SchemaTypes,
   typeBrandKey,
 } from '@pothos/core';
 import type { WithBrand } from './types';
@@ -30,7 +30,9 @@ export class DrizzleObjectRef<
     value: V,
   ): V extends T[] ? { [K in keyof V]: WithBrand<V[K]> } : WithBrand<V> {
     if (Array.isArray(value)) {
-      value.forEach((val) => void brandWithType(val, this.name as never));
+      for (const val of value) {
+        brandWithType(val, this.name as never);
+      }
 
       return value as never;
     }

package/src/schema-builder.ts

@@ -1,23 +1,23 @@
 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 { 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>;
 
@@ -139,12 +139,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 +198,7 @@ schemaBuilderProto.drizzleGraphQLOrderBy = function drizzleGraphQLOrderBy(
   this: PothosSchemaTypes.SchemaBuilder<SchemaTypes>,
   table: string,
   type: GraphQLInputObjectType,
-  options?: { extensions?: {} },
+  options?: { extensions?: object },
 ) {
   return (
     this as typeof this & {
@@ -224,7 +224,7 @@ schemaBuilderProto.drizzleGraphQLFilters = function drizzleGraphQLFilters(
   this: PothosSchemaTypes.SchemaBuilder<SchemaTypes>,
   table: string,
   type: GraphQLInputObjectType,
-  options?: { extensions?: {} },
+  options?: { extensions?: object },
 ) {
   return (
     this as typeof this & {
@@ -250,7 +250,7 @@ schemaBuilderProto.drizzleGraphQLInsert = function drizzleGraphQLInsert(
   this: PothosSchemaTypes.SchemaBuilder<SchemaTypes>,
   table: string,
   type: GraphQLInputObjectType,
-  options?: { extensions?: {} },
+  options?: { extensions?: object },
 ) {
   return (
     this as typeof this & {
@@ -276,7 +276,7 @@ schemaBuilderProto.drizzleGraphQLUpdate = function drizzleGraphQLUpdate(
   this: PothosSchemaTypes.SchemaBuilder<SchemaTypes>,
   table: string,
   type: GraphQLInputObjectType,
-  options?: { extensions?: {} },
+  options?: { extensions?: object },
 ) {
   return (
     this as typeof this & {