@furystack/rest-service 9.0.0 → 9.0.2

package/src/add-cors-header.ts

@@ -0,0 +1,32 @@
+import type { IncomingMessage } from 'http'
+import type { CorsOptions } from './models/cors-options.js'
+import type { ServerResponse } from 'http'
+
+/**
+ * Adds the specified CORS headers to the response
+ * @param options The CORS Options object
+ * @param incomingMessage The incoming message instance
+ * @param serverResponse The outgoing response instance
+ */
+export const addCorsHeaders = (
+  options: CorsOptions,
+  incomingMessage: IncomingMessage,
+  serverResponse: ServerResponse,
+) => {
+  if (
+    incomingMessage.headers &&
+    incomingMessage.headers.origin !== incomingMessage.headers.host &&
+    options.origins.some((origin) => origin === incomingMessage.headers.origin)
+  ) {
+    serverResponse.setHeader('Access-Control-Allow-Origin', incomingMessage.headers.origin as string)
+    if (options.credentials) {
+      serverResponse.setHeader('Access-Control-Allow-Credentials', 'true')
+    }
+    if (options.headers && options.headers.length) {
+      serverResponse.setHeader('Access-Control-Allow-Headers', options.headers.join(', '))
+    }
+    if (options.methods && options.methods.length) {
+      serverResponse.setHeader('Access-Control-Allow-Methods', options.methods.join(', '))
+    }
+  }
+}

package/src/api-manager.ts

@@ -13,11 +13,12 @@ import type { OnRequest } from './server-manager.js'
 import { ServerManager } from './server-manager.js'
 import { NotFoundAction } from './actions/not-found-action.js'
 import type { CorsOptions } from './models/cors-options.js'
-import { Utils } from './utils.js'
 import { ErrorAction } from './actions/error-action.js'
 import './server-response-extensions.js'
 import { HttpUserContext } from './http-user-context.js'
 import type { RequestAction } from './request-action-implementation.js'
+import { addCorsHeaders } from './add-cors-header.js'
+import { readPostBody } from './read-post-body.js'
 
 export type RestApiImplementation<T extends RestApi> = {
   [TMethod in keyof T]: {
@@ -167,7 +168,6 @@ export class ApiManager implements Disposable {
     params: any
   }) {
     await usingAsync(injector.createChild(), async (i) => {
-      const utils = i.getInstance(Utils)
       const httpUserContext = i.getInstance(HttpUserContext)
       i.setExplicitInstance<IdentityContext>(
         {
@@ -182,7 +182,7 @@ export class ApiManager implements Disposable {
           request: req,
           response: res,
           injector: i,
-          getBody: () => utils.readPostBody<any>(req),
+          getBody: () => readPostBody<any>(req),
           headers: req.headers,
           getQuery: () =>
             deserializeQueryParams ? deserializeQueryParams(fullUrl.search) : deserializeQueryString(fullUrl.search),
@@ -213,7 +213,7 @@ export class ApiManager implements Disposable {
       ),
     )
 
-    options.cors && options.injector.getInstance(Utils).addCorsHeaders(options.cors, options.req, options.res)
+    options.cors && addCorsHeaders(options.cors, options.req, options.res)
     if (options.req.method === 'OPTIONS') {
       options.res.writeHead(200)
       options.res.end()
@@ -231,5 +231,5 @@ export class ApiManager implements Disposable {
   }
 
   @Injected(ServerManager)
-  private readonly serverManager!: ServerManager
+  private declare readonly serverManager: ServerManager
 }

package/src/endpoint-generators/create-delete-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('createDeleteEndpoint', () => {
   it('Should delete the entity and report the success', async () => {
     await usingAsync(new Injector(), async (i) => {
+      const port = getPort()
       setupContext(i)
       await useRestService<{ DELETE: { '/:id': DeleteEndpoint<MockClass, 'id'> } }>({
         injector: i,
         root: '/api',
-        port: 1111,
+        port,
         api: {
           DELETE: {
             '/:id': createDeleteEndpoint({ model: MockClass, primaryKey: 'id' }),
@@ -26,7 +28,7 @@ describe('createDeleteEndpoint', () => {
       const countBeforeDelete = await getDataSetFor(i, MockClass, 'id').count(i)
       expect(countBeforeDelete).toBe(1)
 
-      const response = await fetch('http://127.0.0.1:1111/api/mock', { method: 'DELETE' })
+      const response = await fetch(`http://127.0.0.1:${port}/api/mock`, { method: 'DELETE' })
       expect(response.status).toBe(204)
       const txt = await response.text()
       expect(txt).toBe('')

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

@@ -1,6 +1,5 @@
 import type { Constructable } from '@furystack/inject'
 import type { DeleteEndpoint } 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-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/helpers.ts

@@ -25,7 +25,7 @@ export const useRestService = async <T extends RestApi>(api: ImplementApiOptions
 export const useHttpAuthentication = <TUser extends User, TSession extends DefaultSession>(
   injector: Injector,
   settings?: Partial<HttpAuthenticationSettings<TUser, TSession>>,
-) => injector.setExplicitInstance({ ...new HttpAuthenticationSettings(), ...settings }, HttpAuthenticationSettings)
+) => injector.setExplicitInstance(Object.assign(new HttpAuthenticationSettings(), settings), HttpAuthenticationSettings)
 
 /**
  * Sets up a static file server

package/src/http-authentication-settings.ts

@@ -11,8 +11,7 @@ import { DefaultSession } from './models/default-session.js'
 export class HttpAuthenticationSettings<TUser extends User, TSession extends DefaultSession> {
   public model: Constructable<TUser> = User as Constructable<TUser>
 
-  public getUserStore: (storeManager: StoreManager) => PhysicalStore<TUser, keyof TUser> = (sm) =>
-    sm.getStoreFor<TUser, keyof TUser>(User as any, 'username')
+  public getUserStore = (sm: StoreManager) => sm.getStoreFor(User, 'username')
 
   public getSessionStore: (storeManager: StoreManager) => PhysicalStore<TSession, keyof TSession> = (sm) =>
     sm.getStoreFor(DefaultSession, 'sessionId') as unknown as PhysicalStore<TSession, keyof TSession>

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: [] })
 }
@@ -311,4 +310,82 @@ describe('HttpUserContext', () => {
       })
     })
   })
+
+  describe('Changes in the store during the context lifetime', () => {
+    it('Should update user roles', () => {
+      return usingAsync(new Injector(), async (i) => {
+        await prepareInjector(i)
+        const ctx = i.getInstance(HttpUserContext)
+        const userStore = i.getInstance(StoreManager).getStoreFor(User, 'username')
+        userStore.add(testUser)
+
+        const pw = await i.getInstance(PasswordAuthenticator).hasher.createCredential(testUser.username, 'test')
+        await i.getInstance(StoreManager).getStoreFor(PasswordCredential, 'userName').add(pw)
+
+        await ctx.cookieLogin(testUser, { setHeader: vi.fn() })
+
+        const originalUser = await ctx.getCurrentUser(request)
+        expect(originalUser).toEqual(testUser)
+
+        const updatedUser = { ...testUser, roles: ['newFancyRole'] }
+        await userStore.update(testUser.username, updatedUser)
+        const updatedUserFromContext = await ctx.getCurrentUser(request)
+        expect(updatedUserFromContext.roles).toEqual(['newFancyRole'])
+
+        await userStore.update(testUser.username, { ...updatedUser, roles: [] })
+        const reloadedUserFromContext = await ctx.getCurrentUser(request)
+        expect(reloadedUserFromContext.roles).toEqual([])
+      })
+    })
+
+    it('Should remove current user when the user is removed from the store', () => {
+      return usingAsync(new Injector(), async (i) => {
+        await prepareInjector(i)
+        const ctx = i.getInstance(HttpUserContext)
+        const userStore = i.getInstance(StoreManager).getStoreFor(User, 'username')
+        userStore.add(testUser)
+
+        const pw = await i.getInstance(PasswordAuthenticator).hasher.createCredential(testUser.username, 'test')
+        await i.getInstance(StoreManager).getStoreFor(PasswordCredential, 'userName').add(pw)
+
+        await ctx.cookieLogin(testUser, { setHeader: vi.fn() })
+
+        const originalUser = await ctx.getCurrentUser(request)
+        expect(originalUser).toEqual(testUser)
+
+        await userStore.remove(testUser.username)
+
+        await expect(() => ctx.getCurrentUser(request)).rejects.toThrowError(UnauthenticatedError)
+      })
+    })
+
+    it('Should remove current user when the session is removed from the store', () => {
+      return usingAsync(new Injector(), async (i) => {
+        await prepareInjector(i)
+        const ctx = i.getInstance(HttpUserContext)
+        const userStore = i.getInstance(StoreManager).getStoreFor(User, 'username')
+        userStore.add(testUser)
+
+        let sessionId = ''
+
+        const pw = await i.getInstance(PasswordAuthenticator).hasher.createCredential(testUser.username, 'test')
+        await i.getInstance(StoreManager).getStoreFor(PasswordCredential, 'userName').add(pw)
+
+        await ctx.cookieLogin(testUser, {
+          setHeader: (_headerName, headerValue) => {
+            sessionId = headerValue as string
+            return {} as ServerResponse
+          },
+        })
+
+        const originalUser = await ctx.getCurrentUser(request)
+        expect(originalUser).toEqual(testUser)
+
+        const sessionStore = ctx.getSessionStore()
+        await sessionStore.remove(sessionId as string)
+
+        await expect(() => ctx.getCurrentUser(request)).rejects.toThrowError(UnauthenticatedError)
+      })
+    })
+  })
 })

package/src/http-user-context.ts

@@ -84,7 +84,7 @@ export class HttpUserContext {
     return user
   }
 
-  public async getCurrentUser(request: IncomingMessage) {
+  public async getCurrentUser(request: Pick<IncomingMessage, 'headers'>) {
     if (!this.user) {
       this.user = await this.authenticateRequest(request)
       return this.user
@@ -92,7 +92,7 @@ export class HttpUserContext {
     return this.user
   }
 
-  public getSessionIdFromRequest(request: IncomingMessage): string | null {
+  public getSessionIdFromRequest(request: Pick<IncomingMessage, 'headers'>): string | null {
     if (request.headers.cookie) {
       const cookies = request.headers.cookie
         .toString()
@@ -100,7 +100,7 @@ export class HttpUserContext {
         .filter((val) => val.length > 0)
         .map((val) => {
           const [name, value] = val.split('=')
-          return { name: name.trim(), value: value.trim() }
+          return { name: name?.trim(), value: value?.trim() }
         })
       const sessionCookie = cookies.find((c) => c.name === this.authentication.cookieName)
       if (sessionCookie) {
@@ -110,7 +110,7 @@ export class HttpUserContext {
     return null
   }
 
-  public async authenticateRequest(request: IncomingMessage): Promise<User> {
+  public async authenticateRequest(request: Pick<IncomingMessage, 'headers'>): Promise<User> {
     // Basic auth
     if (this.authentication.enableBasicAuth && request.headers.authorization) {
       const authData = Buffer.from(request.headers.authorization.toString().split(' ')[1], 'base64')
@@ -139,7 +139,7 @@ export class HttpUserContext {
    * @param serverResponse A serverResponse to set the cookie
    * @returns the current User
    */
-  public async cookieLogin(user: User, serverResponse: ServerResponse): Promise<User> {
+  public async cookieLogin(user: User, serverResponse: Pick<ServerResponse, 'setHeader'>): Promise<User> {
     const sessionId = randomBytes(32).toString('hex')
     await this.getSessionStore().add({ sessionId, username: user.username })
     serverResponse.setHeader('Set-Cookie', `${this.authentication.cookieName}=${sessionId}; Path=/; HttpOnly`)
@@ -147,10 +147,11 @@ export class HttpUserContext {
     return user
   }
 
-  public async cookieLogout(request: IncomingMessage, response: ServerResponse) {
+  public async cookieLogout(request: Pick<IncomingMessage, 'headers'>, response: Pick<ServerResponse, 'setHeader'>) {
+    this.user = undefined
     const sessionId = this.getSessionIdFromRequest(request)
     response.setHeader('Set-Cookie', `${this.authentication.cookieName}=; Path=/; HttpOnly`)
-    this.user = undefined
+
     if (sessionId) {
       const sessionStore = this.getSessionStore()
       const sessions = await sessionStore.find({ filter: { sessionId: { $eq: sessionId } } })
@@ -159,11 +160,29 @@ 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
+
+  public async init() {
+    this.getUserStore().addListener('onEntityUpdated', ({ id, change }) => {
+      if (this.user?.username === id) {
+        this.user = { ...this.user, ...change }
+      }
+    })
+
+    this.getUserStore().addListener('onEntityRemoved', ({ key }) => {
+      if (this.user?.username === key) {
+        this.user = undefined
+      }
+    })
+
+    this.getSessionStore().addListener('onEntityRemoved', () => {
+      this.user = undefined // as user cannot be determined by the session id anymore
+    })
+  }
 }