add generic type support and improve type safety in GraphQL resolvers

Author: wilburhimself

src/lib/mutation.ts

@@ -3,20 +3,20 @@ import { GraphQLID } from 'graphql';
 
 type GraphQLTypeLike = unknown; // minimal due to local graphql shim
 
-const buildMutation = (
+const buildMutation = <T extends Record<string, unknown>>(
   name: string,
   type: GraphQLTypeLike,
   input: GraphQLTypeLike,
-  model: Entity,
+  model: Entity<T>,
 ) => {
-  const resolver = new Resolver(model);
+  const resolver = new Resolver<T>(model);
   return {
     [`create${name}`]: {
       type: type as unknown,
       args: {
         input: { type: input as unknown },
       },
-      resolve: (_value: unknown, { input }: { input: Record<string, unknown> }) => {
+      resolve: (_value: unknown, { input }: { input: Partial<T> }) => {
         return resolver.create(input);
       },
     },
@@ -26,10 +26,7 @@ const buildMutation = (
         id: { type: GraphQLID },
         input: { type: input as unknown },
       },
-      resolve: (
-        _value: unknown,
-        { id, input }: { id: string | number; input: Record<string, unknown> },
-      ) => {
+      resolve: (_value: unknown, { id, input }: { id: string | number; input: Partial<T> }) => {
         return resolver.update(id, input);
       },
     },

src/lib/query.ts

@@ -1,22 +1,37 @@
 import { GraphQLList, GraphQLInt, GraphQLBoolean, GraphQLString } from 'graphql';
-import Resolver, { Entity } from './resolver';
+import Resolver, { Entity, AllOptions } from './resolver';
 import dotenv from 'dotenv';
 
 dotenv.config();
 
 type GraphQLCompositeType = unknown; // from local graphql shim, keep minimal
 
-type ResolveArgs = {
-  id?: number;
+type ResolveByIdArgs = {
+  id: number;
+  page?: never;
+  limit?: never;
+  offset?: never;
+  all?: never;
+  order?: never;
+};
+
+type ResolveListArgs = {
+  id?: undefined;
   page?: number;
   limit?: number;
   offset?: number;
   all?: boolean;
   order?: string;
 };
 
-const buildQuery = (name: string, type: GraphQLCompositeType, model: Entity) => {
-  const resolver = new Resolver(model);
+type ResolveArgs = ResolveByIdArgs | ResolveListArgs;
+
+const buildQuery = <T extends Record<string, unknown>>(
+  name: string,
+  type: GraphQLCompositeType,
+  model: Entity<T>,
+) => {
+  const resolver = new Resolver<T>(model);
   return {
     [name]: {
       type: new GraphQLList(type as unknown),
@@ -28,23 +43,23 @@ const buildQuery = (name: string, type: GraphQLCompositeType, model: Entity) =>
         all: { type: GraphQLBoolean },
         order: { type: GraphQLString },
       },
-      resolve: (_value: unknown, { id, page, limit, offset, all, order }: ResolveArgs) => {
-        return (() => {
-          if (id) {
-            return [resolver.find(id)];
-          } else {
-            const settings =
-              limit || page || offset || order
-                ? {
-                    currentPage: page ? page : 0,
-                    limit: limit ? limit : Number(process.env.APP_PERPAGE),
-                    offset: offset ? offset : 0,
-                    order: order ? order : '',
-                  }
-                : { all };
-            return resolver.all(settings);
-          }
-        })();
+      resolve: (
+        _value: unknown,
+        { id, page, limit, offset, all, order }: ResolveArgs,
+      ): Promise<T[]> | Array<Promise<T | null>> => {
+        if (id !== undefined) {
+          return [resolver.find(id)];
+        }
+        const settings: AllOptions =
+          limit || page || offset || order
+            ? {
+                currentPage: page ? page : 0,
+                limit: limit ? limit : Number(process.env.APP_PERPAGE),
+                offset: offset ? offset : 0,
+                order: order ? order : '',
+              }
+            : { all };
+        return resolver.all(settings);
       },
     },
   } as Record<string, unknown>;

src/lib/resolver.ts

@@ -15,14 +15,16 @@ export interface Entity<T = Record<string, unknown>> {
   update(item: Partial<T>, opts: UpdateOptions): Promise<unknown>;
 }
 
-type AllOptions = {
+export type AllOptions = {
   currentPage?: number;
   limit?: number;
   offset?: number;
   order?: string;
   all?: boolean;
 };
 
+export type QueryOptions = Pick<AllOptions, 'currentPage' | 'limit' | 'offset' | 'order'>;
+
 class Resolver<T extends Record<string, unknown> = Record<string, unknown>> {
   private entity: Entity<T>;
 
@@ -45,7 +47,7 @@ class Resolver<T extends Record<string, unknown> = Record<string, unknown>> {
     Object.assign(defaults, { order: hasNameField ? 'name ASC' : options?.order });
 
     const settings = Object.assign({}, defaults, options || {});
-    const queryOptions: Record<string, unknown> = {};
+    const queryOptions: QueryOptions = {};
 
     if (!settings.all) {
       Object.assign(queryOptions, {