fix(http): hydrate bound requests from original source

Author: exronnin

packages/auth/tests/express.test.ts

@@ -1,8 +1,10 @@
+import { Request as ArkstackRequest, arkstackHttpPlugin } from '../../http/src'
 import { afterAll, beforeEach, describe, expect, it } from 'vitest'
 import { authSecret, cleanupAuthRecords, createAuthToken, createAuthUser, createPersonalAccessToken } from './fixtures/auth'
 
 import { Auth } from '../src'
 import { Router as ClearRouter } from 'clear-router/express'
+import { Container } from 'clear-router/decorators'
 import { Hash } from '../../common/src'
 import { auth } from '../../driver-express/src/middlewares/auth'
 import express from 'express'
@@ -50,6 +52,62 @@ describe('Express auth integration', () => {
         expect(response.body.authToken).toBe(token)
     })
 
+    it('hydrates the container-bound Arkstack request after authentication', async () => {
+        const user = await createAuthUser()
+        const token = await createAuthToken(user.id)
+
+        await createPersonalAccessToken(user.id, token)
+
+        const app = express()
+        const router = express.Router()
+        const Router = createRouter('bound-request')
+
+        await import('../../http/src/setup')
+        await (Router as any).pluginsReady()
+
+        expect(Container.has(ArkstackRequest)).toBe(true)
+
+        await Router.use(arkstackHttpPlugin)
+        Router.configure({
+            container: {
+                enabled: true,
+                autoDiscover: true,
+            },
+        })
+        Router.get('/account/request', async (ctx) => {
+            const req = await Container.resolve(ArkstackRequest, ctx)
+
+            return {
+                authToken: req?.authToken,
+                authUserFromAuthId: (req?.auth as Auth | undefined)?.user()?.id,
+                authUserId: req?.authUser?.id,
+                constructorName: req?.constructor.name,
+                hasIp: Boolean(req?.ip),
+                hasSource: Boolean(req?.source),
+                isArkstackRequest: req instanceof ArkstackRequest,
+                userId: req?.user?.id,
+            }
+        }, [auth])
+        Router.apply(router)
+        app.use(router)
+
+        const response = await request(app)
+            .get('/account/request')
+            .set('Authorization', `Bearer ${token}`)
+            .expect(200)
+
+        expect(response.body).toMatchObject({
+            authToken: token,
+            constructorName: 'Request',
+            hasIp: true,
+            hasSource: true,
+            isArkstackRequest: true,
+        })
+        expect(String(response.body.authUserFromAuthId)).toBe(String(user.id))
+        expect(String(response.body.authUserId)).toBe(String(user.id))
+        expect(String(response.body.userId)).toBe(String(user.id))
+    })
+
     it('returns an authentication error when the bearer token is missing', async () => {
         const app = express()
 
@@ -89,6 +147,7 @@ describe('Express auth integration', () => {
             const personalAccessToken = await auth.login(email, password)
 
             return res.status(200).json({
+                // @ts-expect-error req.auth is typed from built dependencies
                 authMatches: req.auth === auth,
                 authToken: req.authToken,
                 authUserFromAuthId: req.auth?.user()?.id,
@@ -131,6 +190,7 @@ describe('Express auth integration', () => {
             const personalAccessToken = await auth.create(user)
 
             return res.status(201).json({
+                // @ts-expect-error req.auth is typed from built dependencies
                 authMatches: req.auth === auth,
                 authToken: req.authToken,
                 authUserFromAuthId: req.auth?.user()?.id,

packages/http/src/Contracts/User.ts

@@ -0,0 +1,12 @@
+import { Model } from 'arkormx'
+
+export abstract class User extends Model {
+    [key: string]: any
+    declare email: string
+    declare name: string
+    declare password: string
+    declare createdAt: Date
+    declare updatedAt: Date
+
+    protected static table?: string | undefined = 'users'
+}

packages/http/src/Request.ts

@@ -2,37 +2,75 @@ import { HeaderMap, RequestOptions, RequestSource } from './types/Http'
 import { isRecord, normalizeHeaders, unwrapRequestSource } from './helpers'
 
 import { Request as BaseRequest } from 'clear-router'
+import { User } from '@app/models/User'
 
 /**
  * Represents an HTTP request, providing a consistent interface for accessing request data.
  * 
  * @author 3m1n3nc3
  */
-export class Request<TUser = unknown> extends BaseRequest {
+export class Request<TUser = User> extends BaseRequest {
     readonly headers: HeaderMap
     readonly ip: string | null
     readonly source?: unknown
-    user?: TUser
-    auth?: unknown
-    authUser?: TUser
-    authToken?: string
+    private currentUser?: TUser
+    private currentAuth?: unknown
+    private currentAuthUser?: TUser
+    private currentAuthToken?: string
+
+    get user (): TUser | undefined {
+        return this.getSourceRequest()?.user ?? this.currentUser
+    }
+
+    set user (user: TUser | undefined) {
+        this.currentUser = user
+    }
+
+    get auth (): unknown {
+        return this.getSourceRequest()?.auth ?? this.currentAuth
+    }
+
+    set auth (auth: unknown) {
+        this.currentAuth = auth
+    }
+
+    get authUser (): TUser | undefined {
+        return this.getSourceRequest()?.authUser ?? this.currentAuthUser
+    }
+
+    set authUser (user: TUser | undefined) {
+        this.currentAuthUser = user
+    }
+
+    get authToken (): string | undefined {
+        return this.getSourceRequest()?.authToken ?? this.currentAuthToken
+    }
+
+    set authToken (token: string | undefined) {
+        this.currentAuthToken = token
+    }
 
     constructor(options: RequestOptions<TUser> = {}) {
         super(options)
 
+        const source = options.source ?? options.original
+        const sourceRequest = isRecord(source)
+            ? source as RequestSource<TUser>
+            : undefined
+
         this.headers = normalizeHeaders(options.headers)
         if (this.method)
             this.method = options.method!
         if (this.url)
             this.url = options.url!
         if (this.path)
             this.path = options.path!
-        this.ip = options.ip ?? null
-        this.user = options.user
-        this.auth = options.auth
-        this.authUser = options.authUser
-        this.authToken = options.authToken
-        this.source = options.source
+        this.ip = options.ip ?? sourceRequest?.ip ?? null
+        this.user = options.user ?? sourceRequest?.user
+        this.auth = options.auth ?? sourceRequest?.auth
+        this.authUser = options.authUser ?? sourceRequest?.authUser
+        this.authToken = options.authToken ?? sourceRequest?.authToken
+        this.source = source
 
         globalThis.request = (key?: string) => key ? this.input(key) : this
     }
@@ -60,7 +98,7 @@ export class Request<TUser = unknown> extends BaseRequest {
             auth: request.auth,
             authUser: request.authUser,
             authToken: request.authToken,
-            source,
+            source: request,
         })
     }
 
@@ -103,6 +141,27 @@ export class Request<TUser = unknown> extends BaseRequest {
         return this
     }
 
+    syncFromSource () {
+        if (!isRecord(this.source)) {
+            return this
+        }
+
+        const source = this.source as RequestSource<TUser>
+
+        this.user = source.user ?? this.user
+        this.auth = source.auth ?? this.auth
+        this.authUser = source.authUser ?? this.authUser
+        this.authToken = source.authToken ?? this.authToken
+
+        return this
+    }
+
+    private getSourceRequest (): RequestSource<TUser> | undefined {
+        return isRecord(this.source)
+            ? this.source as RequestSource<TUser>
+            : undefined
+    }
+
     clearAuthentication () {
         this.auth = undefined
         this.authUser = undefined

packages/http/src/helpers.ts

@@ -6,6 +6,10 @@ import { isClass } from '@arkstack/common'
 export const unwrapRequestSource = <TUser> (
     source: RequestSource<TUser>
 ): RequestSource<TUser> => {
+    if (source.original) {
+        return unwrapRequestSource(source.original)
+    }
+
     if (source.headers) {
         return source
     }
@@ -105,4 +109,4 @@ export const resolveMiddleware = <T extends FunctionMiddleware | MiddlewareClass
     }
 
     return middleware as never
-}
+}

packages/http/src/plugins.ts

@@ -27,9 +27,11 @@ export const arkstackHttpPlugin = defineClearRouterPlugin<any, ClearHttpContext>
         })
 
         bind(Request, ({ request, ctx }: { request: Request, ctx: ClearHttpContext }) => {
-            return request instanceof Request
+            const current = request instanceof Request
                 ? request
                 : Request.from(request ?? ctx)!
+
+            return current.syncFromSource()
         })
 
         useHttpContext((context) => {

packages/http/src/types/Http.ts

@@ -21,6 +21,7 @@ export type RequestSource<TUser = unknown> = {
     authToken?: string;
     req?: RequestSource<TUser>;
     request?: RequestSource<TUser>;
+    original?: RequestSource<TUser>;
 }
 
 export type ResponseSource = {
@@ -45,6 +46,7 @@ export type RequestOptions<TUser = unknown> = {
     authUser?: TUser;
     authToken?: string;
     source?: unknown;
+    original?: unknown;
 }
 
 export interface RequestHelper<TUser = unknown> {

packages/http/tests/index.test.ts

@@ -1,8 +1,9 @@
 import { Request, Response, arkstackHttpPlugin, normalizeHeaderValue, normalizeHeaders, unwrapRequestSource } from '../src'
-import { CoreRouter } from 'clear-router/core'
-import { Container } from 'clear-router/decorators'
 import { describe, expect, it, vi } from 'vitest'
 
+import { Container } from 'clear-router/decorators'
+import { CoreRouter } from 'clear-router/core'
+
 describe('HTTP primitives', () => {
     it('normalizes request headers and reads bearer tokens consistently', () => {
         const source = {
@@ -66,13 +67,39 @@ describe('HTTP primitives', () => {
     it('binds the Arkstack Request to the current Clear Router request', async () => {
         await CoreRouter.use(arkstackHttpPlugin)
 
-        const request = new Request({ method: 'POST', path: '/bound' })
+        const user = { id: 1 }
+        const auth = {}
+        const source = {
+            auth: undefined as object | undefined,
+            authToken: undefined as string | undefined,
+            authUser: undefined as typeof user | undefined,
+            headers: {},
+            ip: '127.0.0.1',
+            user: undefined as typeof user | undefined,
+        }
+        const request = new Request({
+            method: 'POST',
+            original: source,
+            path: '/bound',
+        })
+
+        source.auth = auth
+        source.authToken = 'hydrated-token'
+        source.authUser = user
+        source.user = user
+
         const resolved = await Container.resolve(Request, {
             clearRequest: request,
             clearResponse: new Response(),
         })
 
         expect(resolved).toBe(request)
+        expect(resolved?.ip).toBe('127.0.0.1')
+        expect(resolved?.source).toBe(source)
+        expect(resolved?.user).toBe(user)
+        expect(resolved?.auth).toBe(auth)
+        expect(resolved?.authUser).toBe(user)
+        expect(resolved?.authToken).toBe('hydrated-token')
     })
 
     it('proxies response helpers to the underlying source when available', () => {

packages/http/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "paths": {
+      "@app/models/*": ["./src/Contracts/*"]
+    }
+  }
+}