feat!: migrate to msw 2.0 (#294)

Author: kettanaito

package.json

@@ -9,8 +9,8 @@
   "scripts": {
     "start": "tsc -w",
     "format": "prettier src/**/*.ts --write",
-    "test": "jest -c test/jest.config.ts",
-    "test:ts": "tsc -p test/tsconfig.test-d.json",
+    "test": "vitest -c test/vitest.config.ts",
+    "test:ts": "tsc -p test/typings/tsconfig.json",
     "clean": "rimraf ./lib",
     "build": "yarn clean && tsc",
     "release": "release publish",
@@ -27,20 +27,19 @@
     "@faker-js/faker": "^6.3.1",
     "@ossjs/release": "^0.8.0",
     "@types/debug": "^4.1.7",
-    "@types/jest": "^26.0.22",
     "@types/node-fetch": "^2.5.10",
     "commitizen": "^4.2.4",
     "cz-conventional-changelog": "3.3.0",
-    "jest": "^26.6.0",
-    "msw": "^1.0.0",
+    "jsdom": "^22.1.0",
+    "msw": "^2.0.8",
     "node-fetch": "^2.6.1",
     "page-with": "^0.6.0",
     "prettier": "^2.2.1",
     "rimraf": "^3.0.2",
     "simple-git-hooks": "^2.7.0",
-    "ts-jest": "^26.5.5",
     "ts-node": "^9.1.1",
-    "typescript": "4.3.5"
+    "typescript": "4.3.5",
+    "vitest": "^0.34.6"
   },
   "dependencies": {
     "@types/lodash": "^4.14.172",
@@ -58,11 +57,11 @@
     "uuid": "^8.3.1"
   },
   "optionalDependencies": {
-    "msw": "^1.0.0"
+    "msw": "^2.0.8"
   },
   "config": {
     "commitizen": {
       "path": "./node_modules/cz-conventional-changelog"
     }
   }
-}
+}

src/glossary.ts

@@ -1,5 +1,5 @@
 import { GraphQLSchema } from 'graphql'
-import { GraphQLHandler, RestHandler } from 'msw'
+import { GraphQLHandler, HttpHandler } from 'msw'
 import { Database } from './db/Database'
 import { NullableObject, NullableProperty } from './nullable'
 import { PrimaryKey } from './primaryKey'
@@ -167,7 +167,7 @@ export interface ModelAPI<
   /**
    * Generate request handlers of the given type based on the model definition.
    */
-  toHandlers(type: 'rest', baseUrl?: string): RestHandler[]
+  toHandlers(type: 'rest', baseUrl?: string): HttpHandler[]
   /**
    * Generate request handlers of the given type based on the model definition.
    */

src/model/generateGraphQLHandlers.ts

@@ -14,9 +14,8 @@ import {
   GraphQLInputType,
   GraphQLScalarType,
   GraphQLFieldConfigArgumentMap,
-  GraphQLError,
 } from 'graphql'
-import { GraphQLHandler, graphql } from 'msw'
+import { GraphQLHandler, HttpResponse, graphql } from 'msw'
 import { ModelAPI, ModelDefinition, ModelDictionary } from '../glossary'
 import { PrimaryKey } from '../primaryKey'
 import { capitalize } from '../utils/capitalize'
@@ -289,18 +288,14 @@ export function generateGraphQLHandlers<
   const objectSchema = generateGraphQLSchema(modelName, definition, model)
 
   return [
-    target.operation(async (req, res, ctx) => {
-      if (!req.body) {
-        return
-      }
-
+    target.operation(async ({ query, variables }) => {
       const result = await executeGraphQL({
         schema: objectSchema,
-        source: req.body?.query,
-        variableValues: req.variables,
+        source: query,
+        variableValues: variables,
       })
 
-      return res(ctx.data(result.data!), ctx.errors(result.errors))
+      return HttpResponse.json(result)
     }),
   ]
 }

src/model/generateRestHandlers.ts

@@ -1,11 +1,10 @@
 import pluralize from 'pluralize'
 import {
-  RestContext,
-  RestRequest,
   ResponseResolver,
-  rest,
+  http,
   DefaultBodyType,
   PathParams,
+  HttpResponse,
 } from 'msw'
 import {
   Entity,
@@ -65,25 +64,18 @@ export function getResponseStatusByErrorType(
 export function withErrors<
   RequestBodyType extends DefaultBodyType = any,
   RequestParamsType extends PathParams = any,
->(
-  handler: ResponseResolver<
-    RestRequest<RequestBodyType, RequestParamsType>,
-    RestContext
-  >,
-): ResponseResolver<
-  RestRequest<RequestBodyType, RequestParamsType>,
-  RestContext
-> {
-  return (req, res, ctx) => {
+>(resolver: ResponseResolver<any, RequestBodyType, DefaultBodyType>) {
+  return async (...args: Parameters<ResponseResolver>): Promise<any> => {
     try {
-      return handler(req, res, ctx)
+      const response = await resolver(...args)
+      return response
     } catch (error) {
       if (error instanceof Error) {
-        return res(
-          ctx.status(getResponseStatusByErrorType(error as HTTPError)),
-          ctx.json({
-            message: error.message,
-          }),
+        return HttpResponse.json(
+          { message: error.message },
+          {
+            status: getResponseStatusByErrorType(error as HTTPError),
+          },
         )
       }
     }
@@ -153,13 +145,14 @@ export function generateRestHandlers<
   }
 
   return [
-    rest.get(
+    http.get(
       buildUrl(modelPath),
-      withErrors<Entity<Dictionary, ModelName>>((req, res, ctx) => {
+      withErrors<Entity<Dictionary, ModelName>>(({ request }) => {
+        const url = new URL(request.url)
         const { skip, take, cursor, filters } = parseQueryParams(
           modelName,
           modelDefinition,
-          req.url.searchParams,
+          url.searchParams,
         )
 
         let options = { where: filters }
@@ -172,14 +165,14 @@ export function generateRestHandlers<
 
         const records = model.findMany(options)
 
-        return res(ctx.json(records))
+        return HttpResponse.json(records)
       }),
     ),
-    rest.get(
+    http.get(
       buildUrl(`${modelPath}/:${primaryKey}`),
       withErrors<Entity<Dictionary, ModelName>, RequestParams<PrimaryKeyType>>(
-        (req, res, ctx) => {
-          const id = extractPrimaryKey(req.params)
+        ({ params }) => {
+          const id = extractPrimaryKey(params)
           const where: WeakQuerySelectorWhere<PrimaryKeyType> = {
             [primaryKey]: {
               equals: id as string,
@@ -190,22 +183,24 @@ export function generateRestHandlers<
             where: where as any,
           })
 
-          return res(ctx.json(entity))
+          return HttpResponse.json(entity)
         },
       ),
     ),
-    rest.post(
+    http.post(
       buildUrl(modelPath),
-      withErrors<Entity<Dictionary, ModelName>>((req, res, ctx) => {
-        const createdEntity = model.create(req.body)
-        return res(ctx.status(201), ctx.json(createdEntity))
+      withErrors<Entity<Dictionary, ModelName>>(async ({ request }) => {
+        const definition = await request.json()
+        const createdEntity = model.create(definition)
+
+        return HttpResponse.json(createdEntity, { status: 201 })
       }),
     ),
-    rest.put(
+    http.put(
       buildUrl(`${modelPath}/:${primaryKey}`),
       withErrors<Entity<Dictionary, ModelName>, RequestParams<PrimaryKeyType>>(
-        (req, res, ctx) => {
-          const id = extractPrimaryKey(req.params)
+        async ({ request, params }) => {
+          const id = extractPrimaryKey(params)
           const where: WeakQuerySelectorWhere<PrimaryKeyType> = {
             [primaryKey]: {
               equals: id as string,
@@ -214,18 +209,18 @@ export function generateRestHandlers<
           const updatedEntity = model.update({
             strict: true,
             where: where as any,
-            data: req.body,
+            data: await request.json(),
           })!
 
-          return res(ctx.json(updatedEntity))
+          return HttpResponse.json(updatedEntity)
         },
       ),
     ),
-    rest.delete(
+    http.delete(
       buildUrl(`${modelPath}/:${primaryKey}`),
       withErrors<Entity<Dictionary, ModelName>, RequestParams<PrimaryKeyType>>(
-        (req, res, ctx) => {
-          const id = extractPrimaryKey(req.params)
+        ({ params }) => {
+          const id = extractPrimaryKey(params)
           const where: WeakQuerySelectorWhere<PrimaryKeyType> = {
             [primaryKey]: {
               equals: id as string,
@@ -236,7 +231,7 @@ export function generateRestHandlers<
             where: where as any,
           })!
 
-          return res(ctx.json(deletedEntity))
+          return HttpResponse.json(deletedEntity)
         },
       ),
     ),