expose graphql schema via factory.toSchema

src/factory.ts

@@ -15,7 +15,10 @@ import { updateEntity } from './model/updateEntity'
 import { OperationError, OperationErrorType } from './errors/OperationError'
 import { Database } from './db/Database'
 import { generateRestHandlers } from './model/generateRestHandlers'
-import { generateGraphQLHandlers } from './model/generateGraphQLHandlers'
+import {
+  generateGraphQLHandlers,
+  generateGraphQLSchema,
+} from './model/generateGraphQLHandlers'
 import { sync } from './extensions/sync'
 import { removeInternalProperties } from './utils/removeInternalProperties'
 
@@ -256,13 +259,16 @@ function createModelApi<
 
       return records.map(removeInternalProperties)
     },
-    toHandlers(type, baseUrl): any {
+    toHandlers(type: 'rest' | 'graphql', baseUrl: string): any {
       if (type === 'graphql') {
         return generateGraphQLHandlers(modelName, definition, api, baseUrl)
       }
 
       return generateRestHandlers(modelName, definition, api, baseUrl)
     },
+    toGraphQLSchema() {
+      return generateGraphQLSchema(modelName, definition, api)
+    },
   }
 
   return api

src/glossary.ts

@@ -1,3 +1,4 @@
+import { GraphQLSchema } from 'graphql'
 import { GraphQLHandler, RestHandler } from 'msw'
 import {
   BulkQueryOptions,
@@ -174,10 +175,16 @@ export interface ModelAPI<
   /**
    * Generate request handlers of the given type based on the model.
    */
-  toHandlers<HandlerType extends 'rest' | 'graphql'>(
-    type: HandlerType,
-    baseUrl?: string,
-  ): HandlerType extends 'rest' ? RestHandler[] : GraphQLHandler[]
+  toHandlers(type: 'rest', baseUrl?: string): RestHandler[]
+  /**
+   * Generate request handlers of the given type based on the model.
+   */
+  toHandlers(type: 'graphql', baseUrl?: string): GraphQLHandler[]
+
+  /**
+   * Generate a graphql schema based on the model.
+   */
+  toGraphQLSchema(): GraphQLSchema
 }
 
 export type UpdateManyValue<

src/model/generateGraphQLHandlers.ts

@@ -132,16 +132,14 @@ export function definitionToFields(
   )
 }
 
-export function generateGraphQLHandlers<
+export function generateGraphQLSchema<
   Dictionary extends ModelDictionary,
   ModelName extends string
 >(
   modelName: ModelName,
   definition: ModelDefinition,
   model: ModelAPI<Dictionary, ModelName>,
-  baseUrl: string = '',
-): GraphQLHandler[] {
-  const target = baseUrl ? graphql.link(baseUrl) : graphql
+): GraphQLSchema {
   const pluralModelName = pluralize(modelName)
   const capitalModelName = capitalize(modelName)
   const { fields, inputFields, queryInputFields } = definitionToFields(
@@ -268,6 +266,22 @@ export function generateGraphQLHandlers<
     }),
   })
 
+  return objectSchema
+}
+
+export function generateGraphQLHandlers<
+  Dictionary extends ModelDictionary,
+  ModelName extends string
+>(
+  modelName: ModelName,
+  definition: ModelDefinition,
+  model: ModelAPI<Dictionary, ModelName>,
+  baseUrl: string = '',
+): GraphQLHandler[] {
+  const target = baseUrl ? graphql.link(baseUrl) : graphql
+
+  const objectSchema = generateGraphQLSchema(modelName, definition, model)
+
   return [
     target.operation(async (req, res, ctx) => {
       if (!req.body) {

test/model/toGraphQLSchema.test.ts

@@ -0,0 +1,77 @@
+import { datatype } from 'faker'
+import { factory, primaryKey } from '@mswjs/data'
+import { printSchema } from 'graphql'
+
+const db = factory({
+  user: {
+    id: primaryKey(datatype.uuid),
+    firstName: String,
+    age: Number,
+  },
+})
+
+test('generates a graphql schema', () => {
+  const schema = db.user.toGraphQLSchema()
+  expect(printSchema(schema)).toMatchInlineSnapshot(`
+    "type Query {
+      user(where: UserQueryInput): User
+      users(take: Int, skip: Int, cursor: ID, where: UserQueryInput): [User]
+    }
+
+    type User {
+      id: ID
+      firstName: String
+      age: Int
+    }
+
+    input UserQueryInput {
+      id: IdQueryType
+      firstName: StringQueryType
+      age: IntQueryType
+    }
+
+    input IdQueryType {
+      equals: ID
+      notEquals: ID
+      contains: ID
+      notContains: ID
+      in: ID
+      notIn: ID
+    }
+
+    input StringQueryType {
+      equals: String
+      notEquals: String
+      contains: String
+      notContains: String
+      in: String
+      notIn: String
+    }
+
+    input IntQueryType {
+      equals: Int
+      notEquals: Int
+      between: Int
+      notBetween: Int
+      gt: Int
+      gte: Int
+      lt: Int
+      lte: Int
+    }
+
+    type Mutation {
+      createUser(data: UserInput): User
+      updateUser(where: UserQueryInput, data: UserInput): User
+      updateUsers(where: UserQueryInput, data: UserInput): [User]
+      deleteUser(where: UserQueryInput): User
+      deleteUsers(where: UserQueryInput): [User]
+    }
+
+    input UserInput {
+      id: ID
+      firstName: String
+      age: Int
+    }
+    "
+  `)
+})