@furystack/rest-service 6.2.0 → 6.2.2

package/src/endpoint-generators/create-delete-endpoint.spec.ts

@@ -2,7 +2,6 @@ import { usingAsync } from '@furystack/utils'
 import { Injector } from '@furystack/inject'
 import type { DeleteEndpoint } from '@furystack/rest'
 import { createDeleteEndpoint } from './create-delete-endpoint'
-import got from 'got'
 import { MockClass, setupContext } from './utils'
 import { useRestService } from '../helpers'
 import { getDataSetFor } from '@furystack/repository'
@@ -26,9 +25,10 @@ describe('createDeleteEndpoint', () => {
       const countBeforeDelete = await getDataSetFor(i, MockClass, 'id').count(i)
       expect(countBeforeDelete).toBe(1)
 
-      const response = await got('http://127.0.0.1:1111/api/mock', { method: 'DELETE' })
-      expect(response.statusCode).toBe(204)
-      expect(response.body).toBe('')
+      const response = await fetch('http://127.0.0.1:1111/api/mock', { method: 'DELETE' })
+      expect(response.status).toBe(204)
+      const txt = await response.text()
+      expect(txt).toBe('')
 
       const countAfterDelete = await getDataSetFor(i, MockClass, 'id').count(i)
       expect(countAfterDelete).toBe(0)

package/src/endpoint-generators/create-get-collection-endpoint.spec.ts

@@ -1,6 +1,5 @@
 import { usingAsync } from '@furystack/utils'
 import { Injector } from '@furystack/inject'
-import got from 'got'
 import { MockClass, setupContext } from './utils'
 import { createGetCollectionEndpoint } from './create-get-collection-endpoint'
 import type { GetCollectionEndpoint, GetCollectionResult } from '@furystack/rest'
@@ -39,8 +38,9 @@ describe('createGetCollectionEndpoint', () => {
       const count = await getDataSetFor(i, MockClass, 'id').count(i)
       const allEntities = await getDataSetFor(i, MockClass, 'id').find(i, {})
 
-      const response = await got('http://127.0.0.1:1112/api/entities', { method: 'GET' })
-      const json: GetCollectionResult<MockClass> = JSON.parse(response.body)
+      const response = await fetch('http://127.0.0.1:1112/api/entities', { method: 'GET' })
+      expect(response.status).toBe(200)
+      const json: GetCollectionResult<MockClass> = await response.json()
       expect(json.count).toBe(count)
       expect(json.entries).toEqual(allEntities)
     })
@@ -63,10 +63,11 @@ describe('createGetCollectionEndpoint', () => {
       const findOptions: FindOptions<MockClass, Array<keyof MockClass>> = { order: { value: 'ASC' } }
       const count = await getDataSetFor(i, MockClass, 'id').count(i, findOptions.filter)
       const orderedEntities = await getDataSetFor(i, MockClass, 'id').find(i, findOptions)
-      const response = await got(`http://127.0.0.1:1113/api/entities?${serializeToQueryString({ findOptions })}`, {
+      const response = await fetch(`http://127.0.0.1:1113/api/entities?${serializeToQueryString({ findOptions })}`, {
         method: 'GET',
       })
-      const json: GetCollectionResult<MockClass> = JSON.parse(response.body)
+      expect(response.status).toBe(200)
+      const json: GetCollectionResult<MockClass> = await response.json()
       expect(json.count).toBe(count)
       expect(json.entries).toEqual(orderedEntities)
     })
@@ -95,10 +96,11 @@ describe('createGetCollectionEndpoint', () => {
 
       expect(filteredEntities).not.toContainEqual({ id: 'mock2', value: '3' })
 
-      const response = await got(`http://127.0.0.1:1113/api/entities?${serializeToQueryString({ findOptions })}`, {
+      const response = await fetch(`http://127.0.0.1:1113/api/entities?${serializeToQueryString({ findOptions })}`, {
         method: 'GET',
       })
-      const json: GetCollectionResult<MockClass> = JSON.parse(response.body)
+      expect(response.status).toBe(200)
+      const json: GetCollectionResult<MockClass> = await response.json()
       expect(json.count).toBe(count)
       expect(json.entries).toEqual(filteredEntities)
     })
@@ -127,10 +129,13 @@ describe('createGetCollectionEndpoint', () => {
 
       selectedEntities.forEach((e) => expect(e.value).toBeUndefined())
 
-      const response = await got(`http://127.0.0.1:1113/api/entities?${serializeToQueryString({ findOptions })}`, {
+      const response = await fetch(`http://127.0.0.1:1113/api/entities?${serializeToQueryString({ findOptions })}`, {
         method: 'GET',
       })
-      const json: GetCollectionResult<MockClass> = JSON.parse(response.body)
+
+      expect(response.status).toBe(200)
+
+      const json: GetCollectionResult<MockClass> = await response.json()
       expect(json.count).toBe(count)
       expect(json.entries).toEqual(selectedEntities)
     })
@@ -161,10 +166,11 @@ describe('createGetCollectionEndpoint', () => {
       expect(topSkipEntities).not.toContainEqual({ id: 'mock1', value: '4' })
       expect(topSkipEntities).not.toContainEqual({ id: 'mock4', value: '1' })
 
-      const response = await got(`http://127.0.0.1:1113/api/entities?${serializeToQueryString({ findOptions })}`, {
+      const response = await fetch(`http://127.0.0.1:1113/api/entities?${serializeToQueryString({ findOptions })}`, {
         method: 'GET',
       })
-      const json: GetCollectionResult<MockClass> = JSON.parse(response.body)
+      expect(response.status).toBe(200)
+      const json: GetCollectionResult<MockClass> = await response.json()
       expect(json.count).toBe(count)
       expect(json.entries).toEqual(topSkipEntities)
     })

package/src/endpoint-generators/create-get-entity-endpoint.spec.ts

@@ -2,8 +2,6 @@ import { usingAsync } from '@furystack/utils'
 import { Injector } from '@furystack/inject'
 import type { GetEntityEndpoint } from '@furystack/rest'
 import { serializeToQueryString } from '@furystack/rest'
-import type { HTTPError } from 'got'
-import got from 'got'
 import { MockClass, setupContext } from './utils'
 import { createGetEntityEndpoint } from './create-get-entity-endpoint'
 import { getDataSetFor } from '@furystack/repository'
@@ -26,8 +24,10 @@ describe('createGetEntityEndpoint', () => {
       const mockEntity: MockClass = { id: 'mock', value: 'mock' }
       await getDataSetFor(i, MockClass, 'id').add(i, mockEntity)
 
-      const response = await got('http://127.0.0.1:1113/api/mock', { method: 'GET' })
-      expect(JSON.parse(response.body)).toStrictEqual(mockEntity)
+      const response = await fetch('http://127.0.0.1:1113/api/mock', { method: 'GET' })
+      expect(response.status).toBe(200)
+      const body = await response.json()
+      expect(body).toEqual(mockEntity)
     })
   })
 
@@ -47,10 +47,12 @@ describe('createGetEntityEndpoint', () => {
       const mockEntity: MockClass = { id: 'mock', value: 'mock' }
       await getDataSetFor(i, MockClass, 'id').add(i, mockEntity)
 
-      const response = await got(`http://127.0.0.1:1114/api/mock?${serializeToQueryString({ select: ['id'] })}`, {
+      const response = await fetch(`http://127.0.0.1:1114/api/mock?${serializeToQueryString({ select: ['id'] })}`, {
         method: 'GET',
       })
-      expect(JSON.parse(response.body)).toStrictEqual({ id: mockEntity.id })
+      expect(response.status).toBe(200)
+      const body = await response.json()
+      expect(body).toEqual({ id: mockEntity.id })
     })
   })
 
@@ -67,16 +69,10 @@ describe('createGetEntityEndpoint', () => {
           },
         },
       })
-      await new Promise<void>((resolve, reject) => {
-        got(`http://127.0.0.1:1115/api/mock`, { method: 'GET' })
-          .then(() => reject('Should throw'))
-          .catch((err) => {
-            const e: HTTPError = err
-            expect(e.response.statusCode).toBe(404)
-            expect(JSON.parse(e.response.body as string).message).toBe('Entity not found')
-            resolve()
-          })
-      })
+      const result = await fetch(`http://127.0.0.1:1115/api/mock`, { method: 'GET' })
+      expect(result.status).toBe(404)
+      const body = await result.json()
+      expect(body).toEqual({ message: 'Entity not found' })
     })
   })
 })

package/src/endpoint-generators/create-patch-endpoint.spec.ts

@@ -2,7 +2,6 @@ import { usingAsync } from '@furystack/utils'
 import { Injector } from '@furystack/inject'
 import type { PatchEndpoint } from '@furystack/rest'
 import { createPatchEndpoint } from './create-patch-endpoint'
-import got from 'got'
 import { MockClass, setupContext } from './utils'
 import { getDataSetFor } from '@furystack/repository'
 import { useRestService } from '../helpers'
@@ -26,12 +25,13 @@ describe('createPatchEndpoint', () => {
       const countBeforeDelete = await getDataSetFor(i, MockClass, 'id').count(i)
       expect(countBeforeDelete).toBe(1)
 
-      const response = await got('http://127.0.0.1:1116/api/mock', {
+      const response = await fetch('http://127.0.0.1:1116/api/mock', {
         method: 'PATCH',
         body: JSON.stringify({ value: 'updated' }),
       })
-      expect(response.statusCode).toBe(200)
-      expect(response.body).toBe('{}')
+      expect(response.status).toBe(200)
+      const body = await response.json()
+      expect(body).toEqual({})
       const updated = await getDataSetFor(i, MockClass, 'id').get(i, 'mock')
       expect(updated?.value).toBe('updated')
     })

package/src/endpoint-generators/create-post-endpoint.spec.ts

@@ -2,7 +2,6 @@ import { usingAsync } from '@furystack/utils'
 import { Injector } from '@furystack/inject'
 import type { PostEndpoint } from '@furystack/rest'
 import { createPostEndpoint } from './create-post-endpoint'
-import got from 'got'
 import { MockClass, setupContext } from './utils'
 import { useRestService } from '../helpers'
 import { getDataSetFor } from '@furystack/repository'
@@ -22,12 +21,13 @@ describe('createPostEndpoint', () => {
         },
       })
       const entityToPost = { id: 'mock', value: 'posted' }
-      const response = await got('http://127.0.0.1:1117/api/mock', {
+      const response = await fetch('http://127.0.0.1:1117/api/mock', {
         method: 'POST',
         body: JSON.stringify(entityToPost),
       })
-      expect(response.statusCode).toBe(201)
-      expect(JSON.parse(response.body)).toStrictEqual(entityToPost)
+      expect(response.status).toBe(201)
+      const body = await response.json()
+      expect(body).toEqual(entityToPost)
       const posted = await getDataSetFor(i, MockClass, 'id').get(i, entityToPost.id)
       expect(posted?.value).toBe('posted')
     })

package/src/rest-service.integration.spec.ts

@@ -5,7 +5,6 @@ import { GetCurrentUser, IsAuthenticated, LoginAction, LogoutAction } from './ac
 import type { RestApi } from '@furystack/rest'
 import { User, InMemoryStore, addStore } from '@furystack/core'
 import { DefaultSession } from './models/default-session'
-import got from 'got'
 import { JsonResult } from './request-action-implementation'
 import { useHttpAuthentication, useRestService } from './helpers'
 
@@ -81,87 +80,95 @@ describe('@furystack/rest-service inregration tests', () => {
   it('Should respond with 404 when a route is not found', async () => {
     await usingAsync(new Injector(), async (i) => {
       await prepareInjector(i)
-      await expect(got(PathHelper.joinPaths(apiUrl, 'some-route-that-does-not-exists'))).rejects.toThrow(
-        'Response code 404 (Not Found)',
-      )
+      const result = await fetch(PathHelper.joinPaths(apiUrl, 'some-route-that-does-not-exists'))
+      expect(result.ok).toBe(false)
+      expect(result.status).toBe(404)
+      const responseText = await result.json()
+      expect(responseText).toEqual({ error: 'Content not found' })
     })
   })
 
   it('Should respond with 401 for unauthorized request errors', async () => {
     await usingAsync(new Injector(), async (i) => {
       await prepareInjector(i)
-      await expect(got(PathHelper.joinPaths(apiUrl, 'currentUser'), { retry: 0 })).rejects.toThrow(
-        'Response code 401 (Unauthorized)',
-      )
+      const result = await fetch(PathHelper.joinPaths(apiUrl, 'currentUser'))
+      expect(result.ok).toBe(false)
+      expect(result.status).toBe(401)
+      const responseText = await result.json()
+      expect(responseText).toEqual({ error: 'unauthorized' })
     })
   })
 
   it('Should respond with 401 for unauthorized request errors', async () => {
     await usingAsync(new Injector(), async (i) => {
       await prepareInjector(i)
-      await expect(got(PathHelper.joinPaths(apiUrl, 'currentUser'), { retry: 0 })).rejects.toThrow(
-        'Response code 401 (Unauthorized)',
-      )
+      const result = await fetch(PathHelper.joinPaths(apiUrl, 'currentUser'))
+      expect(result.ok).toBe(false)
+      expect(result.status).toBe(401)
+      const responseText = await result.json()
+      expect(responseText).toEqual({ error: 'unauthorized' })
     })
   })
 
   it('Should respond with the correct result body', async () => {
     await usingAsync(new Injector(), async (i) => {
       await prepareInjector(i)
-      const response = await got(PathHelper.joinPaths(apiUrl, 'isAuthenticated'), { retry: 0 })
-      expect(response.statusCode).toBe(200)
-      expect(JSON.parse(response.body)).toStrictEqual({ isAuthenticated: false })
+      const response = await fetch(PathHelper.joinPaths(apiUrl, 'isAuthenticated'))
+      expect(response.status).toBe(200)
+      const result = await response.json()
+      expect(result).toEqual({ isAuthenticated: false })
     })
   })
 
   it('Should be able to read query parameters', async () => {
     await usingAsync(new Injector(), async (i) => {
       await prepareInjector(i)
-      const response = await got(PathHelper.joinPaths(apiUrl, 'testQuery?param1=foo'), { retry: 0 })
-      expect(response.statusCode).toBe(200)
-      expect(JSON.parse(response.body)).toStrictEqual({ param1Value: 'foo' })
+      const response = await fetch(PathHelper.joinPaths(apiUrl, 'testQuery?param1=foo'))
+      expect(response.status).toBe(200)
+      const result = await response.json()
+      expect(result).toEqual({ param1Value: 'foo' })
     })
   })
 
   it('Should be able to read url parameters', async () => {
     await usingAsync(new Injector(), async (i) => {
       await prepareInjector(i)
-      const response = await got(PathHelper.joinPaths(apiUrl, 'testUrlParams/bar'), { retry: 0 })
-      expect(response.statusCode).toBe(200)
-      expect(JSON.parse(response.body)).toStrictEqual({ urlParamValue: 'bar' })
+      const response = await fetch(PathHelper.joinPaths(apiUrl, 'testUrlParams/bar'))
+      expect(response.status).toBe(200)
+      const result = await response.json()
+      expect(result).toEqual({ urlParamValue: 'bar' })
     })
   })
 
   it('Should be able to read post body', async () => {
     await usingAsync(new Injector(), async (i) => {
       await prepareInjector(i)
-      const response = await got(PathHelper.joinPaths(apiUrl, 'testPostBody'), {
+      const response = await fetch(PathHelper.joinPaths(apiUrl, 'testPostBody'), {
         method: 'POST',
         body: JSON.stringify({ value: 'baz' }),
-        retry: 0,
       })
-      expect(response.statusCode).toBe(200)
-      expect(JSON.parse(response.body)).toStrictEqual({ bodyValue: 'baz', body2Value: 'baz' })
+      expect(response.status).toBe(200)
+      const result = await response.json()
+      expect(result).toEqual({ bodyValue: 'baz', body2Value: 'baz' })
     })
   })
 
   it('Should respond with OK to OPTIONS requests', async () => {
     await usingAsync(new Injector(), async (i) => {
       await prepareInjector(i)
-      const response = await got(PathHelper.joinPaths(apiUrl, 'testPostBody'), {
+      const response = await fetch(PathHelper.joinPaths(apiUrl, 'testPostBody'), {
         method: 'OPTIONS',
-        retry: 0,
       })
-      expect(response.statusCode).toBe(200)
+      expect(response.status).toBe(200)
     })
   })
 
   it('Should reject requests outside of the API Root', async () => {
     await usingAsync(new Injector(), async (i) => {
       await prepareInjector(i)
-      await expect(
-        got(PathHelper.joinPaths(`http://${hostName}:${port}`, 'not-my-api-root'), { retry: 0 }),
-      ).rejects.toThrowError('socket hang up')
+      await expect(fetch(PathHelper.joinPaths(`http://${hostName}:${port}`, 'not-my-api-root'))).rejects.toThrowError(
+        'fetch failed',
+      )
     })
   })
 })

package/src/rest.integration.test.ts

@@ -1,6 +1,6 @@
 import { Injector } from '@furystack/inject'
 import type { RestApi } from '@furystack/rest'
-import { createClient } from '@furystack/rest-client-got'
+import { createClient } from '@furystack/rest-client-fetch'
 import { usingAsync } from '@furystack/utils'
 import { JsonResult } from './request-action-implementation'
 import './helpers'
@@ -52,15 +52,15 @@ const createEchoApiServer = async () => {
   }
 }
 
-describe('REST Integration tests with GOT client', () => {
+describe('REST Integration tests with FETCH client', () => {
   it('Should execute a single parameterless GET query', async () => {
     await usingAsync(await createEchoApiServer(), async ({ client }) => {
       const result = await client({
         method: 'GET',
         action: '/plain',
       })
-      expect(result.response.statusCode).toBe(200)
-      expect(result.getJson()).toStrictEqual({})
+      expect(result.response.status).toBe(200)
+      expect(result.result).toEqual({})
     })
   })
 
@@ -74,8 +74,8 @@ describe('REST Integration tests with GOT client', () => {
           value,
         },
       })
-      expect(result.response.statusCode).toBe(200)
-      expect(result.getJson().headers.value).toStrictEqual(value)
+      expect(result.response.status).toBe(200)
+      expect(result.result.headers.value).toEqual(value)
     })
   })
 
@@ -91,8 +91,8 @@ describe('REST Integration tests with GOT client', () => {
           },
         },
       })
-      expect(result.response.statusCode).toBe(200)
-      expect(result.getJson().query.someObject.foo).toStrictEqual(value)
+      expect(result.response.status).toBe(200)
+      expect(result.result.query.someObject.foo).toEqual(value)
     })
   })
 
@@ -106,8 +106,8 @@ describe('REST Integration tests with GOT client', () => {
           id: value,
         },
       })
-      expect(result.response.statusCode).toBe(200)
-      expect(result.getJson().url.id).toEqual(value)
+      expect(result.response.status).toBe(200)
+      expect(result.result.url.id).toEqual(value)
     })
   })
 })