@furystack/rest-service 6.2.1 → 6.2.2

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)
     })
   })
 })

package/src/static-server-manager.spec.ts

@@ -1,6 +1,5 @@
 import { Injector } from '@furystack/inject'
 import { sleepAsync, usingAsync } from '@furystack/utils'
-import got, { RequestError } from 'got'
 import { ServerManager } from './server-manager'
 import { StaticServerManager } from './static-server-manager'
 
@@ -34,16 +33,12 @@ describe('StaticServerManager', () => {
           port,
         })
 
-        try {
-          await got.get(`http://localhost:${port}/not-found.html`)
-        } catch (error) {
-          expect(error).toBeInstanceOf(RequestError)
-          const requestError: RequestError = error as RequestError
-
-          expect(requestError.response?.statusCode).toBe(404)
-          expect(requestError.response?.headers['content-type']).toBe('text/plain')
-          expect(requestError.response?.body).toBe('Not found')
-        }
+        const result = await fetch(`http://localhost:${port}/not-found.html`)
+        expect(result.ok).toBe(false)
+        expect(result.status).toBe(404)
+        expect(result?.headers.get('content-type')).toBe('text/plain')
+        const body = await result.text()
+        expect(body).toBe('Not found')
       })
     })
 
@@ -62,10 +57,10 @@ describe('StaticServerManager', () => {
           },
         })
 
-        const result = await got.get(`http://localhost:${port}/not-found.html`)
+        const result = await fetch(`http://localhost:${port}/not-found.html`)
 
-        expect(result.headers['content-type']).toBe('application/json')
-        expect(result.headers['custom-header']).toBe('custom-value')
+        expect(result.headers.get('content-type')).toBe('application/json')
+        expect(result.headers.get('custom-header')).toBe('custom-value')
       })
     })
 
@@ -84,10 +79,10 @@ describe('StaticServerManager', () => {
           },
         })
 
-        const result = await got.get(`http://localhost:${port}`)
+        const result = await fetch(`http://localhost:${port}`)
 
-        expect(result.headers['content-type']).toBe('application/json')
-        expect(result.headers['custom-header']).toBe('custom-value')
+        expect(result.headers.get('content-type')).toBe('application/json')
+        expect(result.headers.get('custom-header')).toBe('custom-value')
       })
     })
 
@@ -105,10 +100,10 @@ describe('StaticServerManager', () => {
           },
         })
 
-        const result = await got.get(`http://localhost:${port}/README.md`)
+        const result = await fetch(`http://localhost:${port}/README.md`)
 
-        expect(result.headers['content-type']).toBe('text/markdown')
-        expect(result.headers['custom-header']).toBe('custom-value')
+        expect(result.headers.get('content-type')).toBe('text/markdown')
+        expect(result.headers.get('custom-header')).toBe('custom-value')
       })
     })
 
@@ -123,9 +118,9 @@ describe('StaticServerManager', () => {
           port,
         })
 
-        const result = await got.get(`http://localhost:${port}/packages/utils/README.md`)
+        const result = await fetch(`http://localhost:${port}/packages/utils/README.md`)
 
-        expect(result.headers['content-type']).toBe('text/markdown')
+        expect(result.headers.get('content-type')).toBe('text/markdown')
       })
     })
   })
@@ -146,7 +141,9 @@ describe('StaticServerManager', () => {
 
         server.apis[0].onRequest = jest.fn()
 
-        got.get(`http://localhost:${port}/bundleToAnotherFolder/not-found.html`)
+        fetch(`http://localhost:${port}/bundleToAnotherFolder/not-found.html`).catch(() => {
+          /** should fall, ignore */
+        })
 
         await sleepAsync(100)
 
@@ -165,16 +162,12 @@ describe('StaticServerManager', () => {
           port,
         })
 
-        try {
-          await got.get(`http://localhost:${port}/bundle/not-found.html`)
-        } catch (error) {
-          expect(error).toBeInstanceOf(RequestError)
-          const requestError: RequestError = error as RequestError
-
-          expect(requestError.response?.statusCode).toBe(404)
-          expect(requestError.response?.headers['content-type']).toBe('text/plain')
-          expect(requestError.response?.body).toBe('Not found')
-        }
+        const result = await fetch(`http://localhost:${port}/bundle/not-found.html`)
+        expect(result.ok).toBe(false)
+        expect(result.status).toBe(404)
+        expect(result.headers.get('content-type')).toBe('text/plain')
+        const body = await result.text()
+        expect(body).toBe('Not found')
       })
     })
 
@@ -190,9 +183,9 @@ describe('StaticServerManager', () => {
           port,
         })
 
-        const result = await got.get(`http://localhost:${port}/bundle/not-found.html`)
+        const result = await fetch(`http://localhost:${port}/bundle/not-found.html`)
 
-        expect(result.headers['content-type']).toBe('application/json')
+        expect(result.headers.get('content-type')).toBe('application/json')
       })
     })
 
@@ -207,9 +200,9 @@ describe('StaticServerManager', () => {
           port,
         })
 
-        const result = await got.get(`http://localhost:${port}/README.md`)
+        const result = await fetch(`http://localhost:${port}/README.md`)
 
-        expect(result.headers['content-type']).toBe('text/markdown')
+        expect(result.headers.get('content-type')).toBe('text/markdown')
       })
     })
 
@@ -224,9 +217,9 @@ describe('StaticServerManager', () => {
           port,
         })
 
-        const result = await got.get(`http://localhost:${port}/packages/utils/README.md`)
+        const result = await fetch(`http://localhost:${port}/packages/utils/README.md`)
 
-        expect(result.headers['content-type']).toBe('text/markdown')
+        expect(result.headers.get('content-type')).toBe('text/markdown')
       })
     })
   })

package/src/validate.integration.spec.ts

@@ -1,7 +1,6 @@
 import { Injector } from '@furystack/inject'
-import { createClient } from '@furystack/rest-client-got'
+import { createClient, ResponseError } from '@furystack/rest-client-fetch'
 import { usingAsync } from '@furystack/utils'
-import { RequestError } from 'got/dist/source'
 import { JsonResult } from './request-action-implementation'
 import { Validate } from './validate'
 import './helpers'
@@ -75,10 +74,10 @@ describe('Validation integration tests', () => {
             query: undefined as any,
           })
         } catch (error) {
-          if (error instanceof RequestError) {
-            expect(error.message).toBe('Response code 400 (Bad Request)')
-            expect(error.response?.statusCode).toBe(400)
-            const responseJson = JSON.parse(error.response?.body as string)
+          if (error instanceof ResponseError) {
+            expect(error.message).toBe('Bad Request')
+            expect(error.response?.status).toBe(400)
+            const responseJson = await error.response.json()
             expect(responseJson.errors[0].params.missingProperty).toEqual('foo')
             expect(responseJson.errors[1].params.missingProperty).toEqual('bar')
             expect(responseJson.errors[2].params.missingProperty).toEqual('baz')
@@ -96,10 +95,10 @@ describe('Validation integration tests', () => {
             url: undefined as any,
           })
         } catch (error) {
-          if (error instanceof RequestError) {
-            expect(error.message).toBe('Response code 400 (Bad Request)')
-            expect(error.response?.statusCode).toBe(400)
-            const responseJson = JSON.parse(error.response?.body as string)
+          if (error instanceof ResponseError) {
+            expect(error.message).toBe('Bad Request')
+            expect(error.response?.status).toBe(400)
+            const responseJson = await error.response.json()
             expect(responseJson.errors[0].params.type).toEqual('number')
             expect(responseJson.errors[0].instancePath).toEqual('/url/id')
           }
@@ -116,10 +115,10 @@ describe('Validation integration tests', () => {
             headers: undefined as any,
           })
         } catch (error) {
-          if (error instanceof RequestError) {
-            expect(error.message).toBe('Response code 400 (Bad Request)')
-            expect(error.response?.statusCode).toBe(400)
-            const responseJson = JSON.parse(error.response?.body as string)
+          if (error instanceof ResponseError) {
+            expect(error.message).toBe('Bad Request')
+            expect(error.response?.status).toBe(400)
+            const responseJson = await error.response.json()
             expect(
               responseJson.errors.find((e: any) => e.keyword === 'required' && e.message.includes('foo')),
             ).toBeDefined()
@@ -137,10 +136,10 @@ describe('Validation integration tests', () => {
             body: undefined as any,
           })
         } catch (error) {
-          if (error instanceof RequestError) {
-            expect(error.message).toBe('Response code 400 (Bad Request)')
-            expect(error.response?.statusCode).toBe(400)
-            const responseJson = JSON.parse(error.response?.body as string)
+          if (error instanceof ResponseError) {
+            expect(error.message).toBe('Bad Request')
+            expect(error.response?.status).toBe(400)
+            const responseJson = await error.response.json()
             expect(responseJson.errors[0].params.missingProperty).toEqual('body')
           }
         }
@@ -160,11 +159,10 @@ describe('Validation integration tests', () => {
             baz: false,
           },
         })
-        expect(result.response.statusCode).toBe(200)
-        const responseJson = result.getJson()
-        expect(responseJson.foo).toBe('foo')
-        expect(responseJson.bar).toBe(2)
-        expect(responseJson.baz).toBe(false)
+        expect(result.response.status).toBe(200)
+        expect(result.result.foo).toBe('foo')
+        expect(result.result.bar).toBe(2)
+        expect(result.result.baz).toBe(false)
       })
     })
     it('Should validate url', async () => {
@@ -174,9 +172,8 @@ describe('Validation integration tests', () => {
           action: '/validate-url/:id',
           url: { id: 3 },
         })
-        expect(result.response.statusCode).toBe(200)
-        const responseJson = result.getJson()
-        expect(responseJson.id).toBe(3)
+        expect(result.response.status).toBe(200)
+        expect(result.result.id).toBe(3)
       })
     })
     it('Should validate headers', async () => {
@@ -190,11 +187,10 @@ describe('Validation integration tests', () => {
             baz: true,
           },
         })
-        expect(result.response.statusCode).toBe(200)
-        const responseJson = result.getJson()
-        expect(responseJson.foo).toBe('foo')
-        expect(responseJson.bar).toBe(42)
-        expect(responseJson.baz).toBe(true)
+        expect(result.response.status).toBe(200)
+        expect(result.result.foo).toBe('foo')
+        expect(result.result.bar).toBe(42)
+        expect(result.result.baz).toBe(true)
       })
     })
     it('Should validate body', async () => {
@@ -209,11 +205,10 @@ describe('Validation integration tests', () => {
           },
         })
 
-        expect(result.response.statusCode).toBe(200)
-        const responseJson = result.getJson()
-        expect(responseJson.foo).toBe('foo')
-        expect(responseJson.bar).toBe(42)
-        expect(responseJson.baz).toBe(true)
+        expect(result.response.status).toBe(200)
+        expect(result.result.foo).toBe('foo')
+        expect(result.result.bar).toBe(42)
+        expect(result.result.baz).toBe(true)
       })
     })
   })

package/types/actions/error-action.d.ts

@@ -7,8 +7,6 @@ export declare const ErrorAction: RequestAction<{
     body: unknown;
     result: {
         message: string;
-        url?: string;
-        stack?: string;
     };
 }>;
 //# sourceMappingURL=error-action.d.ts.map

package/types/actions/error-action.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-action.d.ts","sourceRoot":"","sources":["../../src/actions/error-action.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAA;AAIrE;;;GAGG;AAEH,eAAO,MAAM,WAAW,EAAE,aAAa,CAAC;IACtC,IAAI,EAAE,OAAO,CAAA;IACb,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAC1D,CAoBA,CAAA"}
+{"version":3,"file":"error-action.d.ts","sourceRoot":"","sources":["../../src/actions/error-action.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAA;AAIrE;;;GAGG;AAEH,eAAO,MAAM,WAAW,EAAE,aAAa,CAAC;IACtC,IAAI,EAAE,OAAO,CAAA;IACb,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CAC5B,CAoBA,CAAA"}

package/types/validate.integration.spec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate.integration.spec.d.ts","sourceRoot":"","sources":["../src/validate.integration.spec.ts"],"names":[],"mappings":"AAMA,OAAO,WAAW,CAAA"}
+{"version":3,"file":"validate.integration.spec.d.ts","sourceRoot":"","sources":["../src/validate.integration.spec.ts"],"names":[],"mappings":"AAKA,OAAO,WAAW,CAAA"}