feat: refactor resolvers to use defineQuery, defineMutation, and defineSubscription for improved structure and type safety

Author: productdevbook

playground/server/graphql/comments/comment-queries.resolver.ts

@@ -1,10 +1,16 @@
-export const define1 = defineResolver({
-  Query: {
-    comments: async (parent, { postId }, context) => {
-      return [
-        { id: '1', content: 'Great post!', postId, authorId: '1' },
-        { id: '2', content: 'Nice work!', postId, authorId: '2' },
-      ]
-    },
+export const define1 = defineQuery({
+  comments: async (parent, { postId }, context) => {
+    return [
+      { id: '1', content: 'Great post!', postId, authorId: '1' },
+      { id: '2', content: 'Nice work!', postId, authorId: '2' },
+    ]
+  },
+})
+
+export const define2 = defineMutation({
+  addComment: async (parent, { input }, context) => {
+    const newComment = { id: '3', ...input, authorId: '1' }
+    // Here you would typically save the new comment to the database
+    return newComment
   },
 })

src/index.ts

@@ -13,9 +13,13 @@ import { clientTypeGeneration, serverTypeGeneration } from './utils/server-type-
 
 export type * from './types'
 
+export { defineGraphQLSchema, defineMutation, defineQuery, defineResolver, defineSubscription, defineType } from './utils'
+
 // This is the main entry point for the nitro-graphql module.
 // It sets up the module, configures the GraphQL endpoints, and handles type generation.
-export interface Resolvers {}
+export interface Resolvers extends Record<string, any> {
+
+}
 
 export default defineNitroModule({
   name: 'nitro-graphql',
@@ -152,6 +156,11 @@ export default defineNitroModule({
         imports: [
           'defineResolver',
           'defineYogaConfig',
+          'defineGraphQLSchema',
+          'defineMutation',
+          'defineQuery',
+          'defineSubscription',
+          'defineType',
         ],
       })
     }

src/rollup.ts

@@ -133,15 +133,12 @@ export function virtualResolvers(app: Nitro) {
       }),
     ]
 
-    const data = imports.map(({ imports }) => {
-      for (const i of imports) {
-        if (i.type === 'resolver') {
-          // return `${i.as}`
-          return `{ resolver: ${i.as} }`
-        }
-      }
-      return undefined
-    }).filter(Boolean).join(',\n')
+    const data = imports
+      .map(({ imports }) =>
+        imports.map(i => `{ resolver: ${i.as} }`).join(',\n'),
+      )
+      .filter(Boolean)
+      .join(',\n')
 
     const content = [
       'export const resolvers = [',

src/types/index.ts

@@ -13,7 +13,7 @@ export type CodegenServerConfig = TypeScriptPluginConfig & TypeScriptResolversPl
 interface IESMImport {
   name: string
   as?: string
-  type: 'resolver' | 'query' | 'mutation' | 'type'
+  type: 'resolver' | 'query' | 'mutation' | 'type' | 'subscription'
 }
 
 export interface GenImport {

src/utils/client-codegen.ts

@@ -1,7 +1,7 @@
 import type { LoadSchemaOptions, UnnormalizedTypeDefPointer } from '@graphql-tools/load'
 import type { Source } from '@graphql-tools/utils'
 import type { GraphQLSchema } from 'graphql'
-import type { CodegenClientConfig } from './types'
+import type { CodegenClientConfig } from '../types'
 import { codegen } from '@graphql-codegen/core'
 import { preset } from '@graphql-codegen/import-types-preset'
 import { plugin as typescriptPlugin } from '@graphql-codegen/typescript'

src/utils/index.ts

@@ -26,6 +26,47 @@ export function defineResolver(
   return resolvers
 }
 
+// Kullanım için utility type
+export type ResolverQuery = Resolvers extends { Query: infer Q }
+  ? Q
+  : never
+
+export function defineQuery(
+  resolvers: Resolvers['Query'] = {},
+): Resolvers {
+  return {
+    Query: {
+      ...resolvers,
+    },
+  }
+}
+
+export function defineMutation(
+  resolvers: Resolvers['Mutation'] = {},
+): Resolvers {
+  return {
+    Mutation: {
+      ...resolvers,
+    },
+  }
+}
+
+export function defineSubscription(
+  resolvers: Resolvers['Subscription'] = {},
+): Resolvers {
+  return {
+    Subscription: {
+      ...resolvers,
+    },
+  }
+}
+
+export function defineType(
+  resolvers: Resolvers,
+): Resolvers {
+  return resolvers
+}
+
 /**
  * Helper function to define GraphQL Yoga configuration with type safety
  */
@@ -64,6 +105,10 @@ export async function scanResolvers(nitro: Nitro) {
     const fileContent = await readFile(file.fullPath, 'utf-8')
     const parsed = await parseAsync(file.fullPath, fileContent)
 
+    const exports: GenImport = {
+      imports: [],
+      specifier: file.fullPath,
+    }
     for (const node of parsed.program.body) {
       if (
         node.type === 'ExportNamedDeclaration'
@@ -74,32 +119,52 @@ export async function scanResolvers(nitro: Nitro) {
           if (decl.type === 'VariableDeclarator' && decl.init && decl.id.type === 'Identifier') {
             if (decl.init && decl.init.type === 'CallExpression') {
               if (decl.init.callee.type === 'Identifier' && decl.init.callee.name === 'defineResolver') {
-                exportName.push({
-                  specifier: file.fullPath,
-                  imports: [{
-                    name: decl.id.name,
-                    type: 'resolver',
-                    as: `_${hash(decl.id.name + file.path).replace(/-/g, '').slice(0, 10)}`,
-                  }],
+                exports.imports.push({
+                  name: decl.id.name,
+                  type: 'resolver',
+                  as: `_${hash(decl.id.name + file.path).replace(/-/g, '').slice(0, 6)}`,
                 })
               }
 
               if (decl.init.callee.type === 'Identifier' && decl.init.callee.name === 'defineQuery') {
-                console.log('Found schema:', decl.id.name)
+                exports.imports.push({
+                  name: decl.id.name,
+                  type: 'query',
+                  as: `_${hash(decl.id.name + file.path).replace(/-/g, '').slice(0, 6)}`,
+                })
               }
 
               if (decl.init.callee.type === 'Identifier' && decl.init.callee.name === 'defineMutation') {
-                console.log('Found mutation:', decl.id.name)
+                exports.imports.push({
+                  name: decl.id.name,
+                  type: 'mutation',
+                  as: `_${hash(decl.id.name + file.path).replace(/-/g, '').slice(0, 6)}`,
+                })
               }
 
               if (decl.init.callee.type === 'Identifier' && decl.init.callee.name === 'defineType') {
-                console.log('Found type:', decl.id.name)
+                exports.imports.push({
+                  name: decl.id.name,
+                  type: 'type',
+                  as: `_${hash(decl.id.name + file.path).replace(/-/g, '').slice(0, 6)}`,
+                })
+              }
+
+              if (decl.init.callee.type === 'Identifier' && decl.init.callee.name === 'defineSubscription') {
+                exports.imports.push({
+                  name: decl.id.name,
+                  type: 'subscription',
+                  as: `_${hash(decl.id.name + file.path).replace(/-/g, '').slice(0, 6)}`,
+                })
               }
             }
           }
         }
       }
     }
+    if (exports.imports.length > 0) {
+      exportName.push(exports)
+    }
   }
 
   return exportName