@furystack/rest-service 8.0.0 → 9.0.1

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

@@ -8,6 +8,7 @@ import type { FindOptions } from '@furystack/core'
 import { getDataSetFor, getRepository } from '@furystack/repository'
 import { useRestService } from '../helpers.js'
 import { describe, it, expect } from 'vitest'
+import { getPort } from '@furystack/core/port-generator'
 
 const addMockEntities = async (i: Injector) =>
   await getRepository(i)
@@ -24,10 +25,11 @@ describe('createGetCollectionEndpoint', () => {
   it('Should return the collection without filter / order', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
+      const port = getPort()
       await useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
         injector: i,
         root: '/api',
-        port: 1112,
+        port,
         api: {
           GET: {
             '/entities': createGetCollectionEndpoint({ model: MockClass, primaryKey: 'id' }),
@@ -39,7 +41,7 @@ describe('createGetCollectionEndpoint', () => {
       const count = await getDataSetFor(i, MockClass, 'id').count(i)
       const allEntities = await getDataSetFor(i, MockClass, 'id').find(i, {})
 
-      const response = await fetch('http://127.0.0.1:1112/api/entities', { method: 'GET' })
+      const response = await fetch(`http://127.0.0.1:${port}/api/entities`, { method: 'GET' })
       expect(response.ok).toBe(true)
       const json: GetCollectionResult<MockClass> = await response.json()
       expect(response.status).toBe(200)
@@ -51,10 +53,11 @@ describe('createGetCollectionEndpoint', () => {
   it('Should return entities in order', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
+      const port = getPort()
       await useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
         injector: i,
         root: '/api',
-        port: 1113,
+        port,
         api: {
           GET: {
             '/entities': createGetCollectionEndpoint({ model: MockClass, primaryKey: 'id' }),
@@ -65,7 +68,7 @@ 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 fetch(`http://127.0.0.1:1113/api/entities?${serializeToQueryString({ findOptions })}`, {
+      const response = await fetch(`http://127.0.0.1:${port}/api/entities?${serializeToQueryString({ findOptions })}`, {
         method: 'GET',
       })
       expect(response.ok).toBe(true)
@@ -79,10 +82,11 @@ describe('createGetCollectionEndpoint', () => {
   it('Should return entities with filtering', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
+      const port = getPort()
       await useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
         injector: i,
         root: '/api',
-        port: 1113,
+        port,
         api: {
           GET: {
             '/entities': createGetCollectionEndpoint({ model: MockClass, primaryKey: 'id' }),
@@ -99,7 +103,7 @@ describe('createGetCollectionEndpoint', () => {
 
       expect(filteredEntities).not.toContainEqual({ id: 'mock2', value: '3' })
 
-      const response = await fetch(`http://127.0.0.1:1113/api/entities?${serializeToQueryString({ findOptions })}`, {
+      const response = await fetch(`http://127.0.0.1:${port}/api/entities?${serializeToQueryString({ findOptions })}`, {
         method: 'GET',
       })
       expect(response.ok).toBe(true)
@@ -113,10 +117,11 @@ describe('createGetCollectionEndpoint', () => {
   it('Should return entities with selecting specific fields', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
+      const port = getPort()
       await useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
         injector: i,
         root: '/api',
-        port: 1113,
+        port,
         api: {
           GET: {
             '/entities': createGetCollectionEndpoint({ model: MockClass, primaryKey: 'id' }),
@@ -133,7 +138,7 @@ describe('createGetCollectionEndpoint', () => {
 
       selectedEntities.forEach((e) => expect(e.value).toBeUndefined())
 
-      const response = await fetch(`http://127.0.0.1:1113/api/entities?${serializeToQueryString({ findOptions })}`, {
+      const response = await fetch(`http://127.0.0.1:${port}/api/entities?${serializeToQueryString({ findOptions })}`, {
         method: 'GET',
       })
 
@@ -148,10 +153,11 @@ describe('createGetCollectionEndpoint', () => {
   it('Should return entities with top/skip', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
+      const port = getPort()
       await useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
         injector: i,
         root: '/api',
-        port: 1113,
+        port,
         api: {
           GET: {
             '/entities': createGetCollectionEndpoint({ model: MockClass, primaryKey: 'id' }),
@@ -170,7 +176,7 @@ describe('createGetCollectionEndpoint', () => {
       expect(topSkipEntities).not.toContainEqual({ id: 'mock1', value: '4' })
       expect(topSkipEntities).not.toContainEqual({ id: 'mock4', value: '1' })
 
-      const response = await fetch(`http://127.0.0.1:1113/api/entities?${serializeToQueryString({ findOptions })}`, {
+      const response = await fetch(`http://127.0.0.1:${port}/api/entities?${serializeToQueryString({ findOptions })}`, {
         method: 'GET',
       })
       expect(response.status).toBe(200)

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

@@ -1,6 +1,5 @@
 import type { Constructable } from '@furystack/inject'
 import type { GetCollectionEndpoint } from '@furystack/rest'
-import '@furystack/repository'
 import type { RequestAction } from '../request-action-implementation.js'
 import { JsonResult } from '../request-action-implementation.js'
 import { getRepository } from '@furystack/repository'

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

@@ -7,15 +7,17 @@ import { createGetEntityEndpoint } from './create-get-entity-endpoint.js'
 import { getDataSetFor } from '@furystack/repository'
 import { useRestService } from '../helpers.js'
 import { describe, it, expect } from 'vitest'
+import { getPort } from '@furystack/core/port-generator'
 
 describe('createGetEntityEndpoint', () => {
   it('Should return the entity', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
+      const port = getPort()
       await useRestService<{ GET: { '/:id': GetEntityEndpoint<MockClass, 'id'> } }>({
         injector: i,
         root: '/api',
-        port: 1113,
+        port,
         api: {
           GET: {
             '/:id': createGetEntityEndpoint({ model: MockClass, primaryKey: 'id' }),
@@ -25,7 +27,7 @@ describe('createGetEntityEndpoint', () => {
       const mockEntity: MockClass = { id: 'mock', value: 'mock' }
       await getDataSetFor(i, MockClass, 'id').add(i, mockEntity)
 
-      const response = await fetch('http://127.0.0.1:1113/api/mock', { method: 'GET' })
+      const response = await fetch(`http://127.0.0.1:${port}/api/mock`, { method: 'GET' })
       expect(response.status).toBe(200)
       const body = await response.json()
       expect(body).toEqual(mockEntity)
@@ -35,10 +37,11 @@ describe('createGetEntityEndpoint', () => {
   it('Should return the entity with the selected fields', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
+      const port = getPort()
       await useRestService<{ GET: { '/:id': GetEntityEndpoint<MockClass, 'id'> } }>({
         injector: i,
         root: '/api',
-        port: 1114,
+        port,
         api: {
           GET: {
             '/:id': createGetEntityEndpoint({ model: MockClass, primaryKey: 'id' }),
@@ -48,7 +51,7 @@ describe('createGetEntityEndpoint', () => {
       const mockEntity: MockClass = { id: 'mock', value: 'mock' }
       await getDataSetFor(i, MockClass, 'id').add(i, mockEntity)
 
-      const response = await fetch(`http://127.0.0.1:1114/api/mock?${serializeToQueryString({ select: ['id'] })}`, {
+      const response = await fetch(`http://127.0.0.1:${port}/api/mock?${serializeToQueryString({ select: ['id'] })}`, {
         method: 'GET',
       })
       expect(response.status).toBe(200)
@@ -60,17 +63,18 @@ describe('createGetEntityEndpoint', () => {
   it('Should return 404 if no entity has been found', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
+      const port = getPort()
       await useRestService<{ GET: { '/:id': GetEntityEndpoint<MockClass, 'id'> } }>({
         injector: i,
         root: '/api',
-        port: 1115,
+        port,
         api: {
           GET: {
             '/:id': createGetEntityEndpoint({ model: MockClass, primaryKey: 'id' }),
           },
         },
       })
-      const result = await fetch(`http://127.0.0.1:1115/api/mock`, { method: 'GET' })
+      const result = await fetch(`http://127.0.0.1:${port}/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-get-entity-endpoint.ts

@@ -1,7 +1,6 @@
 import type { Constructable } from '@furystack/inject'
 import type { GetEntityEndpoint } from '@furystack/rest'
 import { RequestError } from '@furystack/rest'
-import '@furystack/repository'
 import type { RequestAction } from '../request-action-implementation.js'
 import { JsonResult } from '../request-action-implementation.js'
 import { getRepository } from '@furystack/repository'

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

@@ -6,15 +6,17 @@ import { MockClass, setupContext } from './utils.js'
 import { getDataSetFor } from '@furystack/repository'
 import { useRestService } from '../helpers.js'
 import { describe, it, expect } from 'vitest'
+import { getPort } from '@furystack/core/port-generator'
 
 describe('createPatchEndpoint', () => {
   it('Should update the entity and report the success', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
+      const port = getPort()
       await useRestService<{ PATCH: { '/:id': PatchEndpoint<MockClass, 'id'> } }>({
         injector: i,
         root: '/api',
-        port: 1116,
+        port,
         api: {
           PATCH: {
             '/:id': createPatchEndpoint({ model: MockClass, primaryKey: 'id' }),
@@ -26,7 +28,7 @@ describe('createPatchEndpoint', () => {
       const countBeforeDelete = await getDataSetFor(i, MockClass, 'id').count(i)
       expect(countBeforeDelete).toBe(1)
 
-      const response = await fetch('http://127.0.0.1:1116/api/mock', {
+      const response = await fetch(`http://127.0.0.1:${port}/api/mock`, {
         method: 'PATCH',
         body: JSON.stringify({ value: 'updated' }),
       })

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

@@ -1,11 +1,11 @@
 import type { Constructable } from '@furystack/inject'
 import type { PatchEndpoint } from '@furystack/rest'
 import '@furystack/repository'
-import '../incoming-message-extensions.js'
 import type { RequestAction } from '../request-action-implementation.js'
 import { JsonResult } from '../request-action-implementation.js'
 import { getRepository } from '@furystack/repository'
 import type { WithOptionalId } from '@furystack/core'
+import { readPostBody } from '../read-post-body.js'
 
 /**
  * Creates a PATCH endpoint for updating entities
@@ -28,7 +28,7 @@ export const createPatchEndpoint = <
     getUrlParams,
   }) => {
     const { id } = getUrlParams()
-    const patchData = await request.readPostBody<T>()
+    const patchData = await readPostBody<T>(request)
     const dataSet = getRepository(injector).getDataSetFor(options.model, options.primaryKey)
     await dataSet.update(injector, id, patchData)
     return JsonResult({})

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

@@ -6,15 +6,17 @@ import { MockClass, setupContext } from './utils.js'
 import { useRestService } from '../helpers.js'
 import { getDataSetFor } from '@furystack/repository'
 import { describe, it, expect } from 'vitest'
+import { getPort } from '@furystack/core/port-generator'
 
 describe('createPostEndpoint', () => {
   it('Should create the entity and report the success', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
+      const port = getPort()
       await useRestService<{ POST: { '/': PostEndpoint<MockClass, 'id'> } }>({
         injector: i,
         root: '/api',
-        port: 1117,
+        port,
         api: {
           POST: {
             '/': createPostEndpoint({ model: MockClass, primaryKey: 'id' }),
@@ -22,7 +24,7 @@ describe('createPostEndpoint', () => {
         },
       })
       const entityToPost = { id: 'mock', value: 'posted' }
-      const response = await fetch('http://127.0.0.1:1117/api', {
+      const response = await fetch(`http://127.0.0.1:${port}/api`, {
         method: 'POST',
         body: JSON.stringify(entityToPost),
       })

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

@@ -2,11 +2,11 @@ import type { Constructable } from '@furystack/inject'
 import type { PostEndpoint } from '@furystack/rest'
 import { RequestError } from '@furystack/rest'
 import '@furystack/repository'
-import '../incoming-message-extensions.js'
 import type { RequestAction } from '../request-action-implementation.js'
 import { JsonResult } from '../request-action-implementation.js'
 import type { WithOptionalId } from '@furystack/core'
 import { getRepository } from '@furystack/repository'
+import { readPostBody } from '../read-post-body.js'
 /**
  * Creates a POST endpoint for updating entities
  * @param options The options for endpoint creation
@@ -28,7 +28,7 @@ export const createPostEndpoint = <
       options.primaryKey,
     )
 
-    const entityToCreate = await request.readPostBody<TWritableData>()
+    const entityToCreate = await readPostBody<TWritableData>(request)
     const { created } = await dataSet.add(injector, entityToCreate)
     if (!created || !created.length) {
       throw new RequestError('Entity not found', 404)

package/src/endpoint-generators/utils.ts

@@ -6,8 +6,8 @@ import '../helpers.js'
 import { getRepository } from '@furystack/repository'
 
 export class MockClass {
-  id!: string
-  value!: string
+  declare id: string
+  declare value: string
 }
 
 export const setupContext = (i: Injector) => {

package/src/http-user-context.spec.ts

@@ -19,8 +19,7 @@ export const prepareInjector = async (i: Injector) => {
 const setupUser = async (i: Injector, userName: string, password: string) => {
   const sm = i.getInstance(StoreManager)
   const pw = i.getInstance(PasswordAuthenticator)
-  const hasher = pw.getHasher()
-  const cred = await hasher.createCredential(userName, password)
+  const cred = await pw.hasher.createCredential(userName, password)
   await sm.getStoreFor(PasswordCredential, 'userName').add(cred)
   await sm.getStoreFor(User, 'username').add({ username: userName, roles: [] })
 }

package/src/http-user-context.ts

@@ -159,11 +159,11 @@ export class HttpUserContext {
   }
 
   @Injected(HttpAuthenticationSettings)
-  public readonly authentication!: HttpAuthenticationSettings<User, DefaultSession>
+  public declare readonly authentication: HttpAuthenticationSettings<User, DefaultSession>
 
   @Injected(StoreManager)
-  private readonly storeManager!: StoreManager
+  private declare readonly storeManager: StoreManager
 
   @Injected(PasswordAuthenticator)
-  private readonly authenticator!: PasswordAuthenticator
+  private declare readonly authenticator: PasswordAuthenticator
 }

package/src/incoming-message-extensions.ts

@@ -1,20 +1,5 @@
-import http from 'http'
-import { Utils } from './utils.js'
-
 declare module 'http' {
   export interface IncomingMessage {
-    readPostBodyRaw: () => Promise<string>
-    readPostBody: <T>() => Promise<T>
     postBody: unknown
   }
 }
-
-http.IncomingMessage.prototype.readPostBody = async function <T>() {
-  const utils = new Utils()
-  return await utils.readPostBody<T>(this)
-}
-
-http.IncomingMessage.prototype.readPostBodyRaw = async function () {
-  const utils = new Utils()
-  return await utils.readPostBodyRaw(this)
-}

package/src/index.ts

@@ -1,18 +1,18 @@
 export * from './helpers.js'
+export * from './add-cors-header.js'
 export * from './api-manager.js'
 export * from './actions/index.js'
 export * from './authenticate.js'
 export * from './authorize.js'
 export * from './http-authentication-settings.js'
 export * from './http-user-context.js'
-export * from './incoming-message-extensions.js'
 export * from './server-manager.js'
 export * from './server-response-extensions.js'
-export * from './utils.js'
 export * from './models/index.js'
 export * from './endpoint-generators/index.js'
 export * from './schema-validator/index.js'
 export * from './request-action-implementation.js'
 export * from './validate.js'
 export * from './mime-types.js'
+export * from './read-post-body.js'
 export * from './static-server-manager.js'

package/src/models/default-session.ts

@@ -5,10 +5,10 @@ export class DefaultSession {
   /**
    * The generated session identifier
    */
-  public sessionId!: string
+  declare sessionId: string
 
   /**
    * The user's login name for the session
    */
-  public username!: string
+  declare username: string
 }

package/src/read-post-body.ts

@@ -0,0 +1,36 @@
+import type { IncomingMessage } from 'http'
+import './incoming-message-extensions.js'
+
+export const readPostBodyRaw = async (incomingMessage: IncomingMessage) => {
+  if (!incomingMessage.readable) {
+    throw Error('Incoming message is not readable')
+  }
+
+  let body = ''
+  await new Promise<void>((resolve, reject) => {
+    incomingMessage.on('readable', () => {
+      const data = incomingMessage.read()
+      if (data) {
+        body += data
+      }
+    })
+    incomingMessage.on('end', () => {
+      resolve()
+    })
+    incomingMessage.on('error', (err) => {
+      reject(err)
+    })
+  })
+  return body
+}
+
+/**
+ * Reads the post's body and returns a promise with a parsed value
+ * @param incomingMessage The incoming message instance
+ * @returns the parsed object from the post body
+ */
+export const readPostBody = async <T>(incomingMessage: IncomingMessage): Promise<T> => {
+  const body = incomingMessage.postBody || JSON.parse(await readPostBodyRaw(incomingMessage))
+  incomingMessage.postBody = body
+  return body
+}

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

@@ -12,7 +12,7 @@ import { serializeValue } from '@furystack/rest'
 import { getPort } from '@furystack/core/port-generator'
 
 class UserWithPassword extends User {
-  password!: string
+  declare password: string
 }
 
 interface IntegrationTestApi extends RestApi {
@@ -29,9 +29,9 @@ interface IntegrationTestApi extends RestApi {
   }
 }
 
-const prepareInjector = async (i: Injector) => {
+const createIntegrationApi = async () => {
+  const i = new Injector()
   const port = getPort()
-  const hostName = 'localhost'
   const root = 'test-api'
 
   addStore(i, new InMemoryStore({ model: User, primaryKey: 'username' })).addStore(
@@ -44,8 +44,7 @@ const prepareInjector = async (i: Injector) => {
   await useRestService<IntegrationTestApi>({
     injector: i,
     root,
-    port: getPort(),
-    hostName,
+    port,
     cors: {
       credentials: true,
       origins: ['http://localhost:8080'],
@@ -71,23 +70,22 @@ const prepareInjector = async (i: Injector) => {
   })
 
   return {
-    apiUrl: `http://${hostName}:${port}/${root}`,
+    apiUrl: `http://127.0.0.1:${port}/${root}`,
     port,
-    hostName,
+    dispose: i.dispose.bind(i),
   }
 }
 
 describe('@furystack/rest-service inregration tests', () => {
   it('Should be started and disposed', async () => {
-    await usingAsync(new Injector(), async (i) => {
-      await prepareInjector(i)
-    })
+    await usingAsync(await createIntegrationApi(), async () => {})
   })
 
   it('Should respond with 404 when a route is not found', async () => {
-    await usingAsync(new Injector(), async (i) => {
-      const { apiUrl } = await prepareInjector(i)
-      const result = await fetch(PathHelper.joinPaths(apiUrl, 'some-route-that-does-not-exists'))
+    await usingAsync(await createIntegrationApi(), async ({ apiUrl }) => {
+      const result = await fetch(PathHelper.joinPaths(apiUrl, 'some-route-that-does-not-exists'), {
+        method: 'GET',
+      })
       expect(result.ok).toBe(false)
       expect(result.status).toBe(404)
       const responseText = await result.json()
@@ -96,8 +94,7 @@ describe('@furystack/rest-service inregration tests', () => {
   })
 
   it('Should respond with 401 for unauthorized request errors', async () => {
-    await usingAsync(new Injector(), async (i) => {
-      const { apiUrl } = await prepareInjector(i)
+    await usingAsync(await createIntegrationApi(), async ({ apiUrl }) => {
       const result = await fetch(PathHelper.joinPaths(apiUrl, 'currentUser'))
       expect(result.ok).toBe(false)
       expect(result.status).toBe(401)
@@ -107,8 +104,7 @@ describe('@furystack/rest-service inregration tests', () => {
   })
 
   it('Should respond with 401 for unauthorized request errors', async () => {
-    await usingAsync(new Injector(), async (i) => {
-      const { apiUrl } = await prepareInjector(i)
+    await usingAsync(await createIntegrationApi(), async ({ apiUrl }) => {
       const result = await fetch(PathHelper.joinPaths(apiUrl, 'currentUser'))
       expect(result.ok).toBe(false)
       expect(result.status).toBe(401)
@@ -118,8 +114,7 @@ describe('@furystack/rest-service inregration tests', () => {
   })
 
   it('Should respond with the correct result body', async () => {
-    await usingAsync(new Injector(), async (i) => {
-      const { apiUrl } = await prepareInjector(i)
+    await usingAsync(await createIntegrationApi(), async ({ apiUrl }) => {
       const response = await fetch(PathHelper.joinPaths(apiUrl, 'isAuthenticated'))
       expect(response.status).toBe(200)
       const result = await response.json()
@@ -128,9 +123,8 @@ describe('@furystack/rest-service inregration tests', () => {
   })
 
   it('Should be able to read query parameters', async () => {
-    await usingAsync(new Injector(), async (i) => {
-      const { apiUrl } = await prepareInjector(i)
-
+    await usingAsync(await createIntegrationApi(), async ({ apiUrl }) => {
+      console.log('apiUrl', apiUrl)
       const response = await fetch(PathHelper.joinPaths(apiUrl, `testQuery?param1=${serializeValue('foo')}`))
       expect(response.status).toBe(200)
       const result = await response.json()
@@ -139,9 +133,7 @@ describe('@furystack/rest-service inregration tests', () => {
   })
 
   it('Should be able to read url parameters', async () => {
-    await usingAsync(new Injector(), async (i) => {
-      const { apiUrl } = await prepareInjector(i)
-
+    await usingAsync(await createIntegrationApi(), async ({ apiUrl }) => {
       const response = await fetch(PathHelper.joinPaths(apiUrl, 'testUrlParams/bar'))
       expect(response.status).toBe(200)
       const result = await response.json()
@@ -150,9 +142,7 @@ describe('@furystack/rest-service inregration tests', () => {
   })
 
   it('Should be able to read post body', async () => {
-    await usingAsync(new Injector(), async (i) => {
-      const { apiUrl } = await prepareInjector(i)
-
+    await usingAsync(await createIntegrationApi(), async ({ apiUrl }) => {
       const response = await fetch(PathHelper.joinPaths(apiUrl, 'testPostBody'), {
         method: 'POST',
         body: JSON.stringify({ value: 'baz' }),
@@ -164,20 +154,20 @@ describe('@furystack/rest-service inregration tests', () => {
   })
 
   it('Should respond with OK to OPTIONS requests', async () => {
-    await usingAsync(new Injector(), async (i) => {
-      const { apiUrl } = await prepareInjector(i)
-
+    await usingAsync(await createIntegrationApi(), async ({ apiUrl }) => {
       const response = await fetch(PathHelper.joinPaths(apiUrl, 'testPostBody'), {
         method: 'OPTIONS',
+      }).catch((e) => {
+        console.log(e)
+        throw e
       })
       expect(response.status).toBe(200)
     })
   })
 
   it('Should reject requests outside of the API Root', async () => {
-    await usingAsync(new Injector(), async (i) => {
-      const { hostName, port } = await prepareInjector(i)
-      await expect(fetch(PathHelper.joinPaths(`http://${hostName}:${port}`, 'not-my-api-root'))).rejects.toThrowError(
+    await usingAsync(await createIntegrationApi(), async ({ port }) => {
+      await expect(fetch(PathHelper.joinPaths(`http://127.0.0.1:${port}`, 'not-my-api-root'))).rejects.toThrowError(
         'fetch failed',
       )
     })

package/src/rest.integration.test.ts

@@ -56,7 +56,7 @@ const createEchoApiServer = async () => {
     },
   })
   const client = createClient<EchoApi>({
-    endpointUrl: `http://localhost:${port}/api`,
+    endpointUrl: `http://127.0.0.1:${port}/api`,
   })
   return {
     dispose: injector.dispose.bind(injector),

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

@@ -3,23 +3,7 @@ import { sleepAsync, usingAsync } from '@furystack/utils'
 import { ServerManager } from './server-manager.js'
 import { StaticServerManager } from './static-server-manager.js'
 import { describe, it, expect, vi } from 'vitest'
-
-/**
- * Generator for an incremental port number
- * @param initialPort The initial port number
- * @yields a port for testing
- * @returns The Port number
- */
-function* portGenerator(initialPort = 17000) {
-  let port = initialPort
-
-  while (true) {
-    yield port++
-  }
-  return port
-}
-
-const getPort = () => portGenerator().next().value
+import { getPort } from '@furystack/core/port-generator'
 
 describe('StaticServerManager', () => {
   describe('Top level routing', () => {
@@ -33,7 +17,7 @@ describe('StaticServerManager', () => {
           port,
         })
 
-        const result = await fetch(`http://localhost:${port}/not-found.html`)
+        const result = await fetch(`http://127.0.0.1:${port}/not-found.html`)
         expect(result.ok).toBe(false)
         expect(result.status).toBe(404)
         expect(result?.headers.get('content-type')).toBe('text/plain')

package/src/static-server-manager.ts

@@ -18,7 +18,7 @@ export interface StaticServerOptions {
 @Injectable({ lifetime: 'singleton' })
 export class StaticServerManager {
   @Injected(ServerManager)
-  private readonly serverManager!: ServerManager
+  private declare readonly serverManager: ServerManager
 
   private async sendFile({
     fullPath,