@furystack/rest-service 14.0.0 → 14.1.0

package/src/identity-cache-keys.ts

@@ -0,0 +1,31 @@
+/**
+ * Single source of truth for the cache key and cache tag shapes used by the
+ * identity-resolution path. Producer (`cookie-auth-provider.getCacheKey`),
+ * local invalidation (`HttpUserContext.cookieLogout`,
+ * `UserResolutionCache.invalidateByUser`), and any future
+ * `IdentityEventBus` subscribers all derive their strings here so the
+ * local-vs-replicated invalidation paths cannot drift.
+ */
+
+/**
+ * Cache key shape for the cookie-authentication provider. Keying by
+ * session id is safe because session invalidation drops the session
+ * row and the {@link UserResolutionCache} TTL bounds staleness.
+ */
+export type SessionCacheKey = `cookie:${string}`
+
+/**
+ * Tag attached to every {@link UserResolutionCache} entry, derived from
+ * the resolved user's `username`. Enables `removeByTag` invalidation
+ * across every cached session that resolved to a given user — used by
+ * `invalidateByUser` and (later) by `IdentityEventBus` subscribers
+ * acting on `userRolesChanged` / `userDeleted` / `passwordChanged`
+ * events.
+ */
+export type UserCacheTag = `user:${string}`
+
+/** Builds the cookie-auth cache key for `sessionId`. */
+export const sessionCacheKey = (sessionId: string): SessionCacheKey => `cookie:${sessionId}`
+
+/** Builds the user-resolution cache tag for `username`. */
+export const userCacheTag = (username: string): UserCacheTag => `user:${username}`

package/src/identity-event-bus.spec.ts

@@ -0,0 +1,285 @@
+import type { User } from '@furystack/core'
+import { CrossNodeBus, defineInProcessCrossNodeBus, type BusMessage } from '@furystack/cross-node-bus'
+import { createInProcessBusNetwork } from '@furystack/cross-node-bus/testing'
+import { createInjector } from '@furystack/inject'
+import { usingAsync } from '@furystack/utils'
+import { describe, expect, it, vi } from 'vitest'
+import { sessionCacheKey, userCacheTag } from './identity-cache-keys.js'
+import {
+  applyLocalIdentityInvalidation,
+  IDENTITY_EVENT_TOPIC,
+  IdentityEventBus,
+  type IdentityEvent,
+} from './identity-event-bus.js'
+import { UserResolutionCache } from './user-resolution-cache.js'
+
+const userOf = (username: string, roles: readonly string[] = []): User => ({ username, roles: [...roles] })
+
+const populateCache = async (cache: UserResolutionCache, sessionId: string, user: User): Promise<void> => {
+  await cache.resolve(sessionCacheKey(sessionId), async () => user)
+}
+
+describe('IdentityEventBus', () => {
+  describe('applyLocalIdentityInvalidation', () => {
+    it('invalidates by session id for `userLoggedOut`', async () => {
+      await usingAsync(createInjector(), async (i) => {
+        const cache = i.get(UserResolutionCache)
+        await populateCache(cache, 's1', userOf('alice'))
+        expect(cache.size).toBe(1)
+        applyLocalIdentityInvalidation({ type: 'userLoggedOut', sessionId: 's1' }, cache)
+        expect(cache.size).toBe(0)
+      })
+    })
+
+    it('invalidates by session id for `sessionInvalidated`', async () => {
+      await usingAsync(createInjector(), async (i) => {
+        const cache = i.get(UserResolutionCache)
+        await populateCache(cache, 's2', userOf('alice'))
+        applyLocalIdentityInvalidation({ type: 'sessionInvalidated', sessionId: 's2' }, cache)
+        expect(cache.size).toBe(0)
+      })
+    })
+
+    for (const type of ['userRolesChanged', 'userDeleted', 'passwordChanged'] as const) {
+      it(`invalidates every cached session for the named user on \`${type}\``, async () => {
+        await usingAsync(createInjector(), async (i) => {
+          const cache = i.get(UserResolutionCache)
+          await populateCache(cache, 's-a-1', userOf('alice'))
+          await populateCache(cache, 's-a-2', userOf('alice'))
+          await populateCache(cache, 's-b-1', userOf('bob'))
+          expect(cache.size).toBe(3)
+          applyLocalIdentityInvalidation({ type, username: 'alice' }, cache)
+          expect(cache.size).toBe(1)
+          // The remaining entry is bob's.
+          await populateCache(cache, 's-a-3', userOf('alice'))
+          expect(cache.size).toBe(2)
+        })
+      })
+    }
+  })
+
+  describe('publish', () => {
+    it('invalidates the local cache synchronously before awaiting the bus', async () => {
+      await usingAsync(createInjector(), async (i) => {
+        const cache = i.get(UserResolutionCache)
+        await populateCache(cache, 's1', userOf('alice'))
+        const bus = i.get(IdentityEventBus)
+        const pending = bus.publish({ type: 'userLoggedOut', sessionId: 's1' })
+        // Local invalidation must already be visible — the bus.publish promise
+        // is irrelevant for in-process correctness on the originating node.
+        expect(cache.size).toBe(0)
+        await pending
+      })
+    })
+
+    it('fires local subscribers with the typed payload on every event variant', async () => {
+      await usingAsync(createInjector(), async (i) => {
+        const bus = i.get(IdentityEventBus)
+        const events: IdentityEvent[] = []
+        using _u = bus.subscribe('userLoggedOut', (event) => events.push(event))
+        using _s = bus.subscribe('sessionInvalidated', (event) => events.push(event))
+        using _r = bus.subscribe('userRolesChanged', (event) => events.push(event))
+        using _d = bus.subscribe('userDeleted', (event) => events.push(event))
+        using _p = bus.subscribe('passwordChanged', (event) => events.push(event))
+
+        await bus.publish({ type: 'userLoggedOut', sessionId: 's1' })
+        await bus.publish({ type: 'sessionInvalidated', sessionId: 's2' })
+        await bus.publish({ type: 'userRolesChanged', username: 'alice' })
+        await bus.publish({ type: 'userDeleted', username: 'bob' })
+        await bus.publish({ type: 'passwordChanged', username: 'carol' })
+
+        expect(events).toEqual([
+          { type: 'userLoggedOut', sessionId: 's1' },
+          { type: 'sessionInvalidated', sessionId: 's2' },
+          { type: 'userRolesChanged', username: 'alice' },
+          { type: 'userDeleted', username: 'bob' },
+          { type: 'passwordChanged', username: 'carol' },
+        ])
+      })
+    })
+
+    it('does not fire subscribers for other event types', async () => {
+      await usingAsync(createInjector(), async (i) => {
+        const bus = i.get(IdentityEventBus)
+        const handler = vi.fn()
+        using _u = bus.subscribe('userLoggedOut', handler)
+
+        await bus.publish({ type: 'sessionInvalidated', sessionId: 'x' })
+        await bus.publish({ type: 'userRolesChanged', username: 'alice' })
+
+        expect(handler).not.toHaveBeenCalled()
+      })
+    })
+
+    it('rejects when called after dispose', async () => {
+      const injector = createInjector()
+      const bus = injector.get(IdentityEventBus)
+      await injector[Symbol.asyncDispose]()
+      await expect(bus.publish({ type: 'userLoggedOut', sessionId: 's1' })).rejects.toThrow(/disposed/)
+    })
+
+    it('publishes onto the underlying CrossNodeBus topic', async () => {
+      await usingAsync(createInjector(), async (i) => {
+        const crossNodeBus = i.get(CrossNodeBus)
+        const wireHandler = vi.fn<(message: BusMessage) => void>()
+        using _sub = crossNodeBus.subscribe(IDENTITY_EVENT_TOPIC, wireHandler)
+
+        await i.get(IdentityEventBus).publish({ type: 'userRolesChanged', username: 'alice' })
+
+        expect(wireHandler).toHaveBeenCalledTimes(1)
+        expect(wireHandler.mock.calls[0][0].payload).toEqual({ type: 'userRolesChanged', username: 'alice' })
+      })
+    })
+  })
+
+  describe('subscribe', () => {
+    it('returns a Disposable that removes the listener', async () => {
+      await usingAsync(createInjector(), async (i) => {
+        const bus = i.get(IdentityEventBus)
+        const handler = vi.fn()
+        const sub = bus.subscribe('userLoggedOut', handler)
+        await bus.publish({ type: 'userLoggedOut', sessionId: 's1' })
+        sub[Symbol.dispose]()
+        await bus.publish({ type: 'userLoggedOut', sessionId: 's2' })
+        expect(handler).toHaveBeenCalledTimes(1)
+      })
+    })
+
+    it('isolates listener errors so peers still run', async () => {
+      await usingAsync(createInjector(), async (i) => {
+        const bus = i.get(IdentityEventBus)
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined)
+        try {
+          const peer = vi.fn()
+          using _bad = bus.subscribe('userLoggedOut', () => {
+            throw new Error('boom')
+          })
+          using _good = bus.subscribe('userLoggedOut', peer)
+
+          await bus.publish({ type: 'userLoggedOut', sessionId: 's1' })
+
+          expect(peer).toHaveBeenCalledTimes(1)
+          expect(errorSpy).toHaveBeenCalled()
+        } finally {
+          errorSpy.mockRestore()
+        }
+      })
+    })
+
+    it('lets a handler dispose its own subscription mid-emit without skipping peers', async () => {
+      await usingAsync(createInjector(), async (i) => {
+        const bus = i.get(IdentityEventBus)
+        const peer = vi.fn()
+        let selfDispose: Disposable | null = null
+        selfDispose = bus.subscribe('userLoggedOut', () => {
+          selfDispose?.[Symbol.dispose]()
+        })
+        using _peer = bus.subscribe('userLoggedOut', peer)
+
+        await bus.publish({ type: 'userLoggedOut', sessionId: 's1' })
+
+        expect(peer).toHaveBeenCalledTimes(1)
+      })
+    })
+  })
+
+  describe('cross-node delivery', () => {
+    it('logout on node A invalidates the cached session on node B', async () => {
+      using network = createInProcessBusNetwork({ count: 2 })
+      const [busA, busB] = network.buses
+      await usingAsync(createInjector(), async (a) => {
+        await usingAsync(createInjector(), async (b) => {
+          a.bind(CrossNodeBus, defineInProcessCrossNodeBus({ broker: network.broker, nodeId: busA.nodeId }))
+          b.bind(CrossNodeBus, defineInProcessCrossNodeBus({ broker: network.broker, nodeId: busB.nodeId }))
+
+          const cacheA = a.get(UserResolutionCache)
+          const cacheB = b.get(UserResolutionCache)
+          await populateCache(cacheA, 's1', userOf('alice'))
+          await populateCache(cacheB, 's1', userOf('alice'))
+
+          // Force the bus singletons to materialise so subscriptions are live.
+          const facadeA = a.get(IdentityEventBus)
+          b.get(IdentityEventBus)
+
+          await facadeA.publish({ type: 'userLoggedOut', sessionId: 's1' })
+
+          expect(cacheA.size).toBe(0)
+          expect(cacheB.size).toBe(0)
+        })
+      })
+    })
+
+    it('userRolesChanged on node A drops every alice entry on node B', async () => {
+      using network = createInProcessBusNetwork({ count: 2 })
+      const [busA, busB] = network.buses
+      await usingAsync(createInjector(), async (a) => {
+        await usingAsync(createInjector(), async (b) => {
+          a.bind(CrossNodeBus, defineInProcessCrossNodeBus({ broker: network.broker, nodeId: busA.nodeId }))
+          b.bind(CrossNodeBus, defineInProcessCrossNodeBus({ broker: network.broker, nodeId: busB.nodeId }))
+
+          const cacheB = b.get(UserResolutionCache)
+          await populateCache(cacheB, 's-a-1', userOf('alice'))
+          await populateCache(cacheB, 's-a-2', userOf('alice'))
+          await populateCache(cacheB, 's-b-1', userOf('bob'))
+          a.get(IdentityEventBus)
+          b.get(IdentityEventBus)
+
+          await a.get(IdentityEventBus).publish({ type: 'userRolesChanged', username: 'alice' })
+
+          expect(cacheB.size).toBe(1)
+        })
+      })
+    })
+
+    it('local subscribers on node A see the event before the bus broadcasts', async () => {
+      using network = createInProcessBusNetwork({ count: 2 })
+      const [busA, busB] = network.buses
+      await usingAsync(createInjector(), async (a) => {
+        await usingAsync(createInjector(), async (b) => {
+          a.bind(CrossNodeBus, defineInProcessCrossNodeBus({ broker: network.broker, nodeId: busA.nodeId }))
+          b.bind(CrossNodeBus, defineInProcessCrossNodeBus({ broker: network.broker, nodeId: busB.nodeId }))
+
+          const order: string[] = []
+          using _localA = a.get(IdentityEventBus).subscribe('userDeleted', () => order.push('A-local'))
+          using _remoteB = b.get(IdentityEventBus).subscribe('userDeleted', () => order.push('B-remote'))
+
+          await a.get(IdentityEventBus).publish({ type: 'userDeleted', username: 'bob' })
+
+          // A-local fires synchronously inside `publish`; B-remote fires after
+          // the bus accepts the message — same tick in-process, but ordering
+          // is guaranteed by the publish path's local-first contract.
+          expect(order).toEqual(['A-local', 'B-remote'])
+        })
+      })
+    })
+
+    it('drops malformed payloads received over the bus without invalidating the cache', async () => {
+      using network = createInProcessBusNetwork({ count: 2 })
+      const [busA, busB] = network.buses
+      await usingAsync(createInjector(), async (a) => {
+        await usingAsync(createInjector(), async (b) => {
+          a.bind(CrossNodeBus, defineInProcessCrossNodeBus({ broker: network.broker, nodeId: busA.nodeId }))
+          b.bind(CrossNodeBus, defineInProcessCrossNodeBus({ broker: network.broker, nodeId: busB.nodeId }))
+
+          const cacheB = b.get(UserResolutionCache)
+          await populateCache(cacheB, 's1', userOf('alice'))
+          b.get(IdentityEventBus)
+          a.get(IdentityEventBus)
+
+          await a.get(CrossNodeBus).publish(IDENTITY_EVENT_TOPIC, { type: 'unknownEvent', sessionId: 's1' })
+          await a.get(CrossNodeBus).publish(IDENTITY_EVENT_TOPIC, null)
+          await a.get(CrossNodeBus).publish(IDENTITY_EVENT_TOPIC, { type: 'userLoggedOut' })
+
+          expect(cacheB.size).toBe(1)
+        })
+      })
+    })
+  })
+
+  describe('shared helpers', () => {
+    it('exposes the cache-key shape used by the facade subscribers', () => {
+      expect(sessionCacheKey('s1')).toBe('cookie:s1')
+      expect(userCacheTag('alice')).toBe('user:alice')
+    })
+  })
+})

package/src/identity-event-bus.ts

@@ -0,0 +1,230 @@
+import { CrossNodeBus, type BusMessage } from '@furystack/cross-node-bus'
+import { defineService, type Token } from '@furystack/inject'
+import { sessionCacheKey } from './identity-cache-keys.js'
+import { UserResolutionCache } from './user-resolution-cache.js'
+
+/**
+ * Wire topic the facade publishes to and subscribes from on the underlying
+ * {@link CrossNodeBus}. A single topic is used for all event types — internal
+ * dispatch happens by `event.type`. Keeping one topic minimises broker
+ * subscriptions on networked adapters (Redis Streams, NATS) and matches the
+ * EventHub-style fan-out apps already use.
+ */
+export const IDENTITY_EVENT_TOPIC = 'identity/events'
+
+/**
+ * Discriminated union of cross-node identity events. Adding a new variant
+ * **must** also extend {@link applyLocalIdentityInvalidation} so the local
+ * cache stays in sync with the published intent.
+ *
+ * - `userLoggedOut` / `sessionInvalidated` invalidate the cache entry for a
+ *   single session id (same shape — `sessionInvalidated` is meant for
+ *   admin / forced flows where a session row is dropped server-side).
+ * - `userRolesChanged` / `userDeleted` / `passwordChanged` invalidate every
+ *   cached entry that resolved to the named user, regardless of which
+ *   session originally populated it.
+ */
+export type IdentityEvent =
+  | { type: 'userLoggedOut'; sessionId: string }
+  | { type: 'sessionInvalidated'; sessionId: string }
+  | { type: 'userRolesChanged'; username: string }
+  | { type: 'userDeleted'; username: string }
+  | { type: 'passwordChanged'; username: string }
+
+/**
+ * Cross-node identity event facade. Bridges the per-process
+ * {@link UserResolutionCache} to the shared {@link CrossNodeBus} so that
+ * logouts, role flips, password resets and account deletions invalidate
+ * cached identities across every node, not just the one that originated
+ * the change.
+ *
+ * Publishing collapses the staleness window from `userCacheTtlMs`
+ * (default 30 s) to bus latency (single-digit ms with Redis pub/sub).
+ *
+ * **Self-delivery contract.** {@link IdentityEventBus.publish} applies the
+ * matching local invalidation and fires local subscribers synchronously
+ * **before** awaiting the bus. Sibling nodes receive the message via a
+ * `subscribeRemoteOnly` bridge — own publishes never round-trip through the
+ * transport, so duplicate work is impossible.
+ *
+ * @example
+ * ```ts
+ * import type { Injector } from '@furystack/inject'
+ * import { IdentityEventBus } from '@furystack/rest-service'
+ *
+ * declare const injector: Injector
+ * const bus = injector.get(IdentityEventBus)
+ *
+ * using sub = bus.subscribe('userRolesChanged', ({ username }) => {
+ *   console.log('roles changed for', username)
+ * })
+ *
+ * await bus.publish({ type: 'userRolesChanged', username: 'alice' })
+ * ```
+ */
+export interface IdentityEventBus extends Disposable {
+  /**
+   * Publishes a typed identity event. Applies the matching local cache
+   * invalidation synchronously, fires local subscribers synchronously, then
+   * awaits the underlying bus broadcast. Resolves once the message has been
+   * accepted by the transport.
+   */
+  publish(event: IdentityEvent): Promise<void>
+
+  /**
+   * Subscribes to a single event type. Local emits and bus-delivered messages
+   * from sibling nodes both fire the handler. Returns a `Disposable` that
+   * removes the listener on dispose.
+   */
+  subscribe<TType extends IdentityEvent['type']>(
+    type: TType,
+    handler: (event: Extract<IdentityEvent, { type: TType }>) => void,
+  ): Disposable
+}
+
+/**
+ * Applies the cache invalidation that corresponds to `event` against
+ * `userCache`. Centralised so the publish path and the remote-receive path
+ * cannot drift — both call this single helper. Exported for the rare
+ * subsystem (e.g. websocket-api logout-driven socket close) that consumes
+ * an {@link IdentityEvent} and needs to mirror the cache effect.
+ */
+export const applyLocalIdentityInvalidation = (event: IdentityEvent, userCache: UserResolutionCache): void => {
+  switch (event.type) {
+    case 'userLoggedOut':
+    case 'sessionInvalidated':
+      userCache.invalidate(sessionCacheKey(event.sessionId))
+      return
+    case 'userRolesChanged':
+    case 'userDeleted':
+    case 'passwordChanged':
+      userCache.invalidateByUser(event.username)
+      return
+    default: {
+      // Exhaustiveness check: every variant of {@link IdentityEvent} above
+      // must be handled. Adding a new variant without updating this switch
+      // will fail to compile.
+      const _exhaustive: never = event
+      void _exhaustive
+    }
+  }
+}
+
+const isIdentityEvent = (value: unknown): value is IdentityEvent => {
+  if (typeof value !== 'object' || value === null) return false
+  const candidate = value as { type?: unknown; sessionId?: unknown; username?: unknown }
+  switch (candidate.type) {
+    case 'userLoggedOut':
+    case 'sessionInvalidated':
+      return typeof candidate.sessionId === 'string'
+    case 'userRolesChanged':
+    case 'userDeleted':
+    case 'passwordChanged':
+      return typeof candidate.username === 'string'
+    default:
+      return false
+  }
+}
+
+type AnyIdentityHandler = (event: IdentityEvent) => void
+
+class IdentityEventBusImpl implements IdentityEventBus {
+  readonly #bus: CrossNodeBus
+  readonly #userCache: UserResolutionCache
+  readonly #handlers: Map<IdentityEvent['type'], Set<AnyIdentityHandler>> = new Map()
+  readonly #busSubscription: Disposable
+  #disposed = false
+
+  constructor(bus: CrossNodeBus, userCache: UserResolutionCache) {
+    this.#bus = bus
+    this.#userCache = userCache
+    // subscribeRemoteOnly: own publishes invalidate locally inline, so we
+    // only handle messages originating on sibling nodes here.
+    this.#busSubscription = bus.subscribeRemoteOnly(IDENTITY_EVENT_TOPIC, (message) => this.#receive(message))
+  }
+
+  public async publish(event: IdentityEvent): Promise<void> {
+    if (this.#disposed) {
+      throw new Error('IdentityEventBus has been disposed')
+    }
+    applyLocalIdentityInvalidation(event, this.#userCache)
+    this.#emit(event)
+    await this.#bus.publish(IDENTITY_EVENT_TOPIC, event)
+  }
+
+  public subscribe<TType extends IdentityEvent['type']>(
+    type: TType,
+    handler: (event: Extract<IdentityEvent, { type: TType }>) => void,
+  ): Disposable {
+    let handlers = this.#handlers.get(type)
+    if (!handlers) {
+      handlers = new Set()
+      this.#handlers.set(type, handlers)
+    }
+    const wrapped: AnyIdentityHandler = (event) => handler(event as Extract<IdentityEvent, { type: TType }>)
+    handlers.add(wrapped)
+    return {
+      [Symbol.dispose]: () => {
+        const current = this.#handlers.get(type)
+        if (!current) return
+        current.delete(wrapped)
+        if (current.size === 0) this.#handlers.delete(type)
+      },
+    }
+  }
+
+  public [Symbol.dispose](): void {
+    if (this.#disposed) return
+    this.#disposed = true
+    this.#busSubscription[Symbol.dispose]()
+    this.#handlers.clear()
+  }
+
+  #receive(message: BusMessage): void {
+    const { payload } = message
+    if (!isIdentityEvent(payload)) {
+      // Foreign or future-version messages are silently ignored — older nodes
+      // see new event types as no-ops, which is the documented dual-accept
+      // behaviour from the cross-node-bus PRD §12.
+      return
+    }
+    applyLocalIdentityInvalidation(payload, this.#userCache)
+    this.#emit(payload)
+  }
+
+  #emit(event: IdentityEvent): void {
+    const handlers = this.#handlers.get(event.type)
+    if (!handlers) return
+    // Snapshot so a handler that disposes its own subscription mid-emit can't
+    // mutate the iterator. Listener errors are isolated per-handler and
+    // logged — one throwing handler must not poison its peers.
+    for (const handler of [...handlers]) {
+      try {
+        handler(event)
+      } catch (error) {
+        console.error('IdentityEventBus listener threw', { type: event.type, error })
+      }
+    }
+  }
+}
+
+/**
+ * Singleton DI token for the {@link IdentityEventBus}. Resolves a facade that
+ * shares the injector's {@link CrossNodeBus} binding — apps that have not
+ * bound a transport adapter run against the in-process default and
+ * single-node deployments work without configuration.
+ */
+export const IdentityEventBus: Token<IdentityEventBus, 'singleton'> = defineService({
+  name: 'furystack/rest-service/IdentityEventBus',
+  lifetime: 'singleton',
+  factory: ({ inject, onDispose }): IdentityEventBus => {
+    const bus = inject(CrossNodeBus)
+    const userCache = inject(UserResolutionCache)
+    const impl = new IdentityEventBusImpl(bus, userCache)
+    onDispose(() => {
+      // eslint-disable-next-line furystack/prefer-using-wrapper -- onDispose is the teardown hook
+      impl[Symbol.dispose]()
+    })
+    return impl
+  },
+})

package/src/index.ts

@@ -9,6 +9,8 @@ export * from './helpers.js'
 export * from './http-authentication-settings.js'
 export * from './http-server-pool.js'
 export * from './http-user-context.js'
+export * from './identity-cache-keys.js'
+export * from './identity-event-bus.js'
 export * from './login-response-strategy.js'
 export * from './mime-types.js'
 export * from './models/index.js'
@@ -20,5 +22,6 @@ export * from './schema-validator/index.js'
 export * from './server-response-extensions.js'
 export * from './server-telemetry.js'
 export * from './static-site-runtime.js'
+export * from './user-resolution-cache.js'
 export * from './user-store.js'
 export * from './validate.js'

package/src/login-response-strategy.ts

@@ -3,6 +3,7 @@ import { useSystemIdentityContext } from '@furystack/core'
 import type { Injector } from '@furystack/inject'
 import { randomBytes } from 'crypto'
 
+import type { createPasswordLoginAction } from './actions/password-login-action.js'
 import { HttpAuthenticationSettings } from './http-authentication-settings.js'
 import type { ActionResult } from './request-action-implementation.js'
 import { JsonResult } from './request-action-implementation.js'

package/src/openapi/generate-openapi-document.spec.ts

@@ -275,7 +275,7 @@ describe('generateOpenApiDocument', () => {
     it('Should use generic object schema when no schemaName', () => {
       const api: ApiEndpointSchema['endpoints'] = {
         GET: {
-          '/test': { path: '/test', isAuthenticated: false, schemaName: '', schema: null as unknown },
+          '/test': { path: '/test', isAuthenticated: false, schemaName: '', schema: null },
         },
       }
 
@@ -300,7 +300,7 @@ describe('generateOpenApiDocument', () => {
     it('Should not add schema to components when schema is falsy', () => {
       const api: ApiEndpointSchema['endpoints'] = {
         GET: {
-          '/test': { path: '/test', isAuthenticated: false, schemaName: 'Empty', schema: null as unknown },
+          '/test': { path: '/test', isAuthenticated: false, schemaName: 'Empty', schema: null },
         },
       }
 

package/src/proxy-manager.spec.ts

@@ -897,7 +897,7 @@ describe('ProxyManager', () => {
             targetBaseUrl: `http://localhost:${targetPort}`,
             sourcePort: proxyPort,
             headers: () => ({
-              'X-Array-Header': ['value1', 'value2', 'value3'] as unknown as string,
+              'X-Array-Header': ['value1', 'value2', 'value3'],
             }),
           })
 
@@ -935,7 +935,7 @@ describe('ProxyManager', () => {
             sourcePort: proxyPort,
             headers: () => ({
               'X-Defined-Header': 'defined',
-              'X-Undefined-Header': undefined as unknown as string,
+              'X-Undefined-Header': undefined,
             }),
           })
 
@@ -1135,7 +1135,7 @@ describe('ProxyManager', () => {
         const targetWss = new WebSocketServer({ server: targetServer })
 
         targetWss.on('connection', (ws, req) => {
-          receivedProtocol = req.headers['sec-websocket-protocol'] as string
+          receivedProtocol = req.headers['sec-websocket-protocol']
           ws.send('connected')
         })
 
@@ -1714,9 +1714,9 @@ describe('ProxyManager', () => {
             sourcePort: proxyPort,
             enableWebsockets: true,
             headers: () => ({
-              'X-Number-Header': 42 as unknown as string,
-              'X-Array-Header': ['val1', 'val2'] as unknown as string,
-              'X-Undefined-Header': undefined as unknown as string,
+              'X-Number-Header': 42,
+              'X-Array-Header': ['val1', 'val2'],
+              'X-Undefined-Header': undefined,
               'X-String-Header': 'string-value',
             }),
           })