ts-procedures 2.0.1 → 2.1.1

package/src/implementations/http/express-rpc/index.test.ts

@@ -10,7 +10,7 @@ import { RPCConfig } from '../../types.js'
  * ExpressRPCAppBuilder Test Suite
  *
  * Tests the RPC-style Express integration for ts-procedures.
- * This builder creates POST routes at `/rpc/{name}/{version}` paths.
+ * This builder creates POST routes at `/{name}/{version}` paths (with optional pathPrefix).
  */
 describe('ExpressRPCAppBuilder', () => {
   // --------------------------------------------------------------------------
@@ -31,7 +31,7 @@ describe('ExpressRPCAppBuilder', () => {
       const app = builder.build()
 
       // JSON body should be parsed automatically
-      const res = await request(app).post('/rpc/echo/1').send({ message: 'hello' })
+      const res = await request(app).post('/echo/1').send({ message: 'hello' })
 
       expect(res.status).toBe(200)
       expect(res.body).toEqual({ message: 'hello' })
@@ -54,7 +54,7 @@ describe('ExpressRPCAppBuilder', () => {
 
       // Without json middleware, body won't be parsed (req.body is undefined)
       const res = await request(app)
-        .post('/rpc/echo/1')
+        .post('/echo/1')
         .set('Content-Type', 'application/json')
         .send(JSON.stringify({ message: 'hello' }))
 
@@ -76,6 +76,77 @@ describe('ExpressRPCAppBuilder', () => {
     })
   })
 
+  // --------------------------------------------------------------------------
+  // pathPrefix Option Tests
+  // --------------------------------------------------------------------------
+  describe('pathPrefix option', () => {
+    test('uses custom pathPrefix for all routes', async () => {
+      const builder = new ExpressRPCAppBuilder({ pathPrefix: '/api/v1' })
+      const RPC = Procedures<{}, RPCConfig>()
+
+      RPC.Create('Test', { name: 'test', version: 1 }, async () => ({ ok: true }))
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      const res = await request(app).post('/api/v1/test/1').send({})
+      expect(res.status).toBe(200)
+      expect(res.body).toEqual({ ok: true })
+    })
+
+    test('pathPrefix without leading slash gets normalized', async () => {
+      const builder = new ExpressRPCAppBuilder({ pathPrefix: 'custom' })
+      const RPC = Procedures<{}, RPCConfig>()
+
+      RPC.Create('Test', { name: 'test', version: 1 }, async () => ({ ok: true }))
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      const res = await request(app).post('/custom/test/1').send({})
+      expect(res.status).toBe(200)
+    })
+
+    test('no prefix when pathPrefix not specified', async () => {
+      const builder = new ExpressRPCAppBuilder()
+      const RPC = Procedures<{}, RPCConfig>()
+
+      RPC.Create('Test', { name: 'test', version: 1 }, async () => ({ ok: true }))
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      const res = await request(app).post('/test/1').send({})
+      expect(res.status).toBe(200)
+    })
+
+    test('pathPrefix appears in generated docs', () => {
+      const builder = new ExpressRPCAppBuilder({ pathPrefix: '/api' })
+      const RPC = Procedures<{}, RPCConfig>()
+
+      RPC.Create('Test', { name: 'test', version: 1 }, async () => ({}))
+
+      builder.register(RPC, () => ({}))
+      builder.build()
+
+      expect(builder.docs[0]!.path).toBe('/api/test/1')
+    })
+
+    test('pathPrefix /rpc restores original behavior', async () => {
+      const builder = new ExpressRPCAppBuilder({ pathPrefix: '/rpc' })
+      const RPC = Procedures<{}, RPCConfig>()
+
+      RPC.Create('Users', { name: 'users', version: 1 }, async () => ({ users: [] }))
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      const res = await request(app).post('/rpc/users/1').send({})
+      expect(res.status).toBe(200)
+      expect(builder.docs[0]!.path).toBe('/rpc/users/1')
+    })
+  })
+
   // --------------------------------------------------------------------------
   // Lifecycle Hooks Tests
   // --------------------------------------------------------------------------
@@ -90,11 +161,11 @@ describe('ExpressRPCAppBuilder', () => {
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      await request(app).post('/rpc/test/1').send({})
+      await request(app).post('/test/1').send({})
 
       expect(onRequestStart).toHaveBeenCalledTimes(1)
       expect(onRequestStart.mock.calls[0]![0]).toHaveProperty('method', 'POST')
-      expect(onRequestStart.mock.calls[0]![0]).toHaveProperty('path', '/rpc/test/1')
+      expect(onRequestStart.mock.calls[0]![0]).toHaveProperty('path', '/test/1')
     })
 
     test('onRequestEnd is called after response finishes', async () => {
@@ -107,7 +178,7 @@ describe('ExpressRPCAppBuilder', () => {
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      await request(app).post('/rpc/test/1').send({})
+      await request(app).post('/test/1').send({})
 
       expect(onRequestEnd).toHaveBeenCalledTimes(1)
       expect(onRequestEnd.mock.calls[0]![0]).toHaveProperty('method', 'POST')
@@ -124,7 +195,7 @@ describe('ExpressRPCAppBuilder', () => {
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      await request(app).post('/rpc/test/1').send({})
+      await request(app).post('/test/1').send({})
 
       expect(onSuccess).toHaveBeenCalledTimes(1)
       expect(onSuccess.mock.calls[0]![0]).toHaveProperty('name', 'Test')
@@ -142,7 +213,7 @@ describe('ExpressRPCAppBuilder', () => {
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      await request(app).post('/rpc/test/1').send({})
+      await request(app).post('/test/1').send({})
 
       expect(onSuccess).not.toHaveBeenCalled()
     })
@@ -165,7 +236,7 @@ describe('ExpressRPCAppBuilder', () => {
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      await request(app).post('/rpc/test/1').send({})
+      await request(app).post('/test/1').send({})
 
       expect(order).toEqual(['start', 'handler', 'success', 'end'])
     })
@@ -190,7 +261,7 @@ describe('ExpressRPCAppBuilder', () => {
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      const res = await request(app).post('/rpc/test/1').send({})
+      const res = await request(app).post('/test/1').send({})
 
       expect(errorHandler).toHaveBeenCalledTimes(1)
       expect(errorHandler.mock.calls[0]![0]).toHaveProperty('name', 'Test')
@@ -211,7 +282,7 @@ describe('ExpressRPCAppBuilder', () => {
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      const res = await request(app).post('/rpc/test/1').send({})
+      const res = await request(app).post('/test/1').send({})
 
       // Default error handler returns error message in JSON body
       expect(res.body).toHaveProperty('error')
@@ -231,7 +302,7 @@ describe('ExpressRPCAppBuilder', () => {
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      const res = await request(app).post('/rpc/test/1').send({})
+      const res = await request(app).post('/test/1').send({})
 
       // Unhandled exceptions are caught and returned as error response
       expect(res.body).toHaveProperty('error')
@@ -276,15 +347,53 @@ describe('ExpressRPCAppBuilder', () => {
 
       const app = builder.build()
 
-      const publicRes = await request(app).post('/rpc/public/1').send({})
-      const privateRes = await request(app).post('/rpc/private/1').send({})
+      const publicRes = await request(app).post('/public/1').send({})
+      const privateRes = await request(app).post('/private/1').send({})
 
       expect(publicRes.body).toEqual({ isPublic: true })
       expect(privateRes.body).toEqual({ isPrivate: true })
     })
 
-    test('context resolver receives Express request object', async () => {
-      const contextResolver = vi.fn((req) => ({
+    test('context can be a static object', async () => {
+      const factoryContext = { requestId: 'req-123' }
+
+      const builder = new ExpressRPCAppBuilder()
+      const RPC = Procedures<{ requestId: string }, RPCConfig>()
+
+      RPC.Create('GetRequestId', { name: 'get-request-id', version: 1 }, async (ctx) => ({
+        id: ctx.requestId,
+      }))
+
+      builder.register(RPC, factoryContext)
+      const app = builder.build()
+
+      const res = await request(app).post('/get-request-id/1').send({})
+
+      expect(res.body).toEqual({ id: 'req-123' })
+    })
+
+    test('factoryContext can be async function', async () => {
+      const factoryContext = vi.fn(async () => {
+        return { requestId: 'req-456' }
+      })
+
+      const builder = new ExpressRPCAppBuilder()
+      const RPC = Procedures<{ requestId: string }, RPCConfig>()
+
+      RPC.Create('GetRequestId', { name: 'get-request-id', version: 1 }, async (ctx) => ({
+        id: ctx.requestId,
+      }))
+
+      builder.register(RPC, factoryContext)
+      const app = builder.build()
+
+      await request(app).post('/get-request-id/1').send({})
+
+      expect(factoryContext).toHaveBeenCalledTimes(1)
+    })
+
+    test('factoryContext function receives Express request object', async () => {
+      const factoryContext = vi.fn((req) => ({
         authHeader: req.headers.authorization,
       }))
 
@@ -295,14 +404,14 @@ describe('ExpressRPCAppBuilder', () => {
         auth: ctx.authHeader,
       }))
 
-      builder.register(RPC, contextResolver)
+      builder.register(RPC, factoryContext)
       const app = builder.build()
 
-      await request(app).post('/rpc/get-auth/1').set('Authorization', 'Bearer token123').send({})
+      await request(app).post('/get-auth/1').set('Authorization', 'Bearer token123').send({})
 
-      expect(contextResolver).toHaveBeenCalledTimes(1)
-      expect(contextResolver.mock.calls[0]![0]).toHaveProperty('headers')
-      expect(contextResolver.mock.calls[0]![0].headers).toHaveProperty(
+      expect(factoryContext).toHaveBeenCalledTimes(1)
+      expect(factoryContext.mock.calls[0]![0]).toHaveProperty('headers')
+      expect(factoryContext.mock.calls[0]![0].headers).toHaveProperty(
         'authorization',
         'Bearer token123'
       )
@@ -323,8 +432,8 @@ describe('ExpressRPCAppBuilder', () => {
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      const res1 = await request(app).post('/rpc/method-one/1').send({})
-      const res2 = await request(app).post('/rpc/method-two/2').send({})
+      const res1 = await request(app).post('/method-one/1').send({})
+      const res2 = await request(app).post('/method-two/2').send({})
 
       expect(res1.status).toBe(200)
       expect(res2.status).toBe(200)
@@ -353,8 +462,8 @@ describe('ExpressRPCAppBuilder', () => {
       builder.build()
 
       expect(builder.docs).toHaveLength(2)
-      expect(builder.docs[0]!.path).toBe('/rpc/method-one/1')
-      expect(builder.docs[1]!.path).toBe('/rpc/nested/method/2')
+      expect(builder.docs[0]!.path).toBe('/method-one/1')
+      expect(builder.docs[1]!.path).toBe('/nested/method/2')
     })
 
     test('passes request body to handler as params', async () => {
@@ -370,7 +479,7 @@ describe('ExpressRPCAppBuilder', () => {
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      const res = await request(app).post('/rpc/echo/1').send({ data: 'test-data' })
+      const res = await request(app).post('/echo/1').send({ data: 'test-data' })
 
       expect(res.body).toEqual({ received: 'test-data' })
     })
@@ -384,7 +493,7 @@ describe('ExpressRPCAppBuilder', () => {
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      const res = await request(app).get('/rpc/test/1')
+      const res = await request(app).get('/test/1')
 
       expect(res.status).toBe(404)
     })
@@ -400,24 +509,24 @@ describe('ExpressRPCAppBuilder', () => {
       builder = new ExpressRPCAppBuilder()
     })
 
-    test("simple string: 'users' → /rpc/users/1", () => {
+    test("simple string: 'users' → /users/1", () => {
       const path = builder.makeRPCHttpRoutePath({ name: 'users', version: 1 })
-      expect(path).toBe('/rpc/users/1')
+      expect(path).toBe('/users/1')
     })
 
-    test("array name: ['users', 'get-by-id'] → /rpc/users/get-by-id/1", () => {
+    test("array name: ['users', 'get-by-id'] → /users/get-by-id/1", () => {
       const path = builder.makeRPCHttpRoutePath({ name: ['users', 'get-by-id'], version: 1 })
-      expect(path).toBe('/rpc/users/get-by-id/1')
+      expect(path).toBe('/users/get-by-id/1')
     })
 
-    test("camelCase: 'getUserById' → /rpc/get-user-by-id/1", () => {
+    test("camelCase: 'getUserById' → /get-user-by-id/1", () => {
       const path = builder.makeRPCHttpRoutePath({ name: 'getUserById', version: 1 })
-      expect(path).toBe('/rpc/get-user-by-id/1')
+      expect(path).toBe('/get-user-by-id/1')
     })
 
-    test("PascalCase: 'GetUserById' → /rpc/get-user-by-id/1", () => {
+    test("PascalCase: 'GetUserById' → /get-user-by-id/1", () => {
       const path = builder.makeRPCHttpRoutePath({ name: 'GetUserById', version: 1 })
-      expect(path).toBe('/rpc/get-user-by-id/1')
+      expect(path).toBe('/get-user-by-id/1')
     })
 
     test('version number included in path', () => {
@@ -425,9 +534,9 @@ describe('ExpressRPCAppBuilder', () => {
       const pathV2 = builder.makeRPCHttpRoutePath({ name: 'test', version: 2 })
       const pathV99 = builder.makeRPCHttpRoutePath({ name: 'test', version: 99 })
 
-      expect(pathV1).toBe('/rpc/test/1')
-      expect(pathV2).toBe('/rpc/test/2')
-      expect(pathV99).toBe('/rpc/test/99')
+      expect(pathV1).toBe('/test/1')
+      expect(pathV2).toBe('/test/2')
+      expect(pathV99).toBe('/test/99')
     })
 
     test('handles mixed case in array segments', () => {
@@ -435,7 +544,7 @@ describe('ExpressRPCAppBuilder', () => {
         name: ['UserModule', 'getActiveUsers'],
         version: 1,
       })
-      expect(path).toBe('/rpc/user-module/get-active-users/1')
+      expect(path).toBe('/user-module/get-active-users/1')
     })
   })
 
@@ -454,16 +563,17 @@ describe('ExpressRPCAppBuilder', () => {
       const returnSchema = v.object({ name: v.string() })
 
       const RPC = Procedures<{}, RPCConfig>()
-      const { info } = RPC.Create(
+      RPC.Create(
         'GetUser',
         { name: 'users', version: 1, schema: { params: paramsSchema, returnType: returnSchema } },
         async () => ({ name: 'test' })
       )
 
-      const procedure = RPC.getProcedures()[0]!
-      const doc = builder.buildRpcHttpRouteDoc(procedure)
+      builder.register(RPC, () => ({}))
+      builder.build()
 
-      expect(doc.path).toBe('/rpc/users/1')
+      const doc = builder.docs[0]!
+      expect(doc.path).toBe('/users/1')
       expect(doc.method).toBe('post')
       expect(doc.jsonSchema.body).toBeDefined()
       expect(doc.jsonSchema.response).toBeDefined()
@@ -473,9 +583,10 @@ describe('ExpressRPCAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
       RPC.Create('NoParams', { name: 'no-params', version: 1 }, async () => ({ ok: true }))
 
-      const procedure = RPC.getProcedures()[0]!
-      const doc = builder.buildRpcHttpRouteDoc(procedure)
+      builder.register(RPC, () => ({}))
+      builder.build()
 
+      const doc = builder.docs[0]!
       expect(doc.jsonSchema.body).toBeUndefined()
     })
 
@@ -487,9 +598,10 @@ describe('ExpressRPCAppBuilder', () => {
         async () => ({})
       )
 
-      const procedure = RPC.getProcedures()[0]!
-      const doc = builder.buildRpcHttpRouteDoc(procedure)
+      builder.register(RPC, () => ({}))
+      builder.build()
 
+      const doc = builder.docs[0]!
       expect(doc.jsonSchema.body).toBeDefined()
       expect(doc.jsonSchema.response).toBeUndefined()
     })
@@ -499,10 +611,10 @@ describe('ExpressRPCAppBuilder', () => {
       RPC.Create('Test1', { name: 't1', version: 1 }, async () => ({}))
       RPC.Create('Test2', { name: 't2', version: 2 }, async () => ({}))
 
-      const procedures = RPC.getProcedures()
+      builder.register(RPC, () => ({}))
+      builder.build()
 
-      procedures.forEach((proc) => {
-        const doc = builder.buildRpcHttpRouteDoc(proc)
+      builder.docs.forEach((doc) => {
         expect(doc.method).toBe('post')
       })
     })
@@ -570,24 +682,24 @@ describe('ExpressRPCAppBuilder', () => {
       const app = builder.build()
 
       // Test public endpoints
-      const versionRes = await request(app).post('/rpc/system/version/1').send({})
+      const versionRes = await request(app).post('/system/version/1').send({})
       expect(versionRes.status).toBe(200)
       expect(versionRes.body).toEqual({ version: '1.0.0' })
 
-      const healthRes = await request(app).post('/rpc/health/1').send({})
+      const healthRes = await request(app).post('/health/1').send({})
       expect(healthRes.status).toBe(200)
       expect(healthRes.body).toEqual({ status: 'ok' })
 
       // Test authenticated endpoints
       const profileRes = await request(app)
-        .post('/rpc/users/profile/1')
+        .post('/users/profile/1')
         .set('X-User-Id', 'user-123')
         .send({})
       expect(profileRes.status).toBe(200)
       expect(profileRes.body).toEqual({ userId: 'user-123', source: 'auth' })
 
       const updateRes = await request(app)
-        .post('/rpc/users/profile/2')
+        .post('/users/profile/2')
         .set('X-User-Id', 'user-456')
         .send({ name: 'John Doe' })
       expect(updateRes.status).toBe(200)
@@ -597,10 +709,10 @@ describe('ExpressRPCAppBuilder', () => {
       expect(builder.docs).toHaveLength(4)
 
       const paths = builder.docs.map((d) => d.path)
-      expect(paths).toContain('/rpc/system/version/1')
-      expect(paths).toContain('/rpc/health/1')
-      expect(paths).toContain('/rpc/users/profile/1')
-      expect(paths).toContain('/rpc/users/profile/2')
+      expect(paths).toContain('/system/version/1')
+      expect(paths).toContain('/health/1')
+      expect(paths).toContain('/users/profile/1')
+      expect(paths).toContain('/users/profile/2')
 
       // Verify hooks were called
       expect(events).toContain('request-start')

package/src/implementations/http/express-rpc/index.ts

@@ -6,6 +6,31 @@ import { castArray } from 'es-toolkit/compat'
 import { ExpressFactoryItem, ExtractContext, ProceduresFactory } from './types.js'
 
 export type { RPCConfig, RPCHttpRouteDoc }
+
+export type ExpressRPCAppBuilderConfig = {
+  /**
+   * An existing Express application instance to use.
+   * When provided, ensure to set up necessary middleware (e.g., json/body parser) beforehand.
+   * If not provided, a new instance will be created.
+   */
+  app?: express.Express
+  /** Optional path prefix for all RPC routes. */
+  pathPrefix?: string
+  onRequestStart?: (req: express.Request) => void
+  onRequestEnd?: (req: express.Request, res: express.Response) => void
+  onSuccess?: (
+    procedure: TProcedureRegistration,
+    req: express.Request,
+    res: express.Response
+  ) => void
+  error?: (
+    procedure: TProcedureRegistration,
+    req: express.Request,
+    res: express.Response,
+    error: Error
+  ) => void
+}
+
 /**
  * Builder class for creating an Express application with RPC routes.
  *
@@ -27,29 +52,7 @@ export class ExpressRPCAppBuilder {
    *
    * @param config
    */
-  constructor(
-    readonly config?: {
-      /**
-       * An existing Express application instance to use.
-       * When provided, ensure to set up necessary middleware (e.g., json/body parser) beforehand.
-       * If not provided, a new instance will be created.
-       */
-      app?: express.Express
-      onRequestStart?: (req: express.Request) => void
-      onRequestEnd?: (req: express.Request, res: express.Response) => void
-      onSuccess?: (
-        procedure: TProcedureRegistration,
-        req: express.Request,
-        res: express.Response
-      ) => void
-      error?: (
-        procedure: TProcedureRegistration,
-        req: express.Request,
-        res: express.Response,
-        error: Error
-      ) => void
-    }
-  ) {
+  constructor(readonly config?: ExpressRPCAppBuilderConfig) {
     if (config?.app) {
       this._app = config.app
     } else {
@@ -74,6 +77,34 @@ export class ExpressRPCAppBuilder {
     }
   }
 
+  /**
+   * Generates the RPC route path based on the RPC configuration.
+   * The RPCConfig name can be a string or an array of strings to form nested paths.
+   *
+   * Example
+   *  name: ['string', 'string-string', 'string']
+   *  path: /string/string-string/string/version
+   * @param config
+   */
+  static makeRPCHttpRoutePath({ config, prefix }: { prefix?: string; config: RPCConfig }) {
+    const normalizedPrefix = prefix
+      ? (prefix.startsWith('/') ? prefix : `/${prefix}`)
+      : ''
+
+    return `${normalizedPrefix}/${castArray(config.name).map(kebabCase).join('/')}/${String(config.version).trim()}`
+  }
+
+  /**
+   * Instance method wrapper for makeRPCHttpRoutePath that uses the builder's pathPrefix.
+   * @param config - The RPC configuration
+   */
+  makeRPCHttpRoutePath(config: RPCConfig): string {
+    return ExpressRPCAppBuilder.makeRPCHttpRoutePath({
+      config,
+      prefix: this.config?.pathPrefix,
+    })
+  }
+
   private factories: ExpressFactoryItem<any>[] = []
 
   private _app: express.Express = express()
@@ -88,15 +119,18 @@ export class ExpressRPCAppBuilder {
   }
 
   /**
-   * Registers a procedure factory with its context resolver.
-   * @param factory
-   * @param contextResolver
+   * Registers a procedure factory with its context.
+   * @param factory - The procedure factory created by Procedures<Context, RPCConfig>()
+   * @param factoryContext - The context for procedure handlers. Can be a direct value,
+   *                         a sync function (req) => Context, or an async function (req) => Promise<Context>
    */
   register<TFactory extends ProceduresFactory>(
     factory: TFactory,
-    contextResolver: (req: express.Request) => ExtractContext<TFactory>
+    factoryContext:
+      | ExtractContext<TFactory>
+      | ((req: express.Request) => ExtractContext<TFactory> | Promise<ExtractContext<TFactory>>)
   ): this {
-    this.factories.push({ factory, contextResolver } as ExpressFactoryItem<any>)
+    this.factories.push({ factory, factoryContext } as ExpressFactoryItem<any>)
     return this
   }
 
@@ -105,7 +139,7 @@ export class ExpressRPCAppBuilder {
    * @return express.Application
    */
   build(): express.Application {
-    this.factories.forEach(({ factory, contextResolver }) => {
+    this.factories.forEach(({ factory, factoryContext }) => {
       factory.getProcedures().map((procedure: TProcedureRegistration<any, RPCConfig>) => {
         const route = this.buildRpcHttpRouteDoc(procedure)
 
@@ -113,7 +147,12 @@ export class ExpressRPCAppBuilder {
 
         this._app[route.method](route.path, async (req, res) => {
           try {
-            res.json(await procedure.handler(contextResolver(req), req.body))
+            const context =
+              typeof factoryContext === 'function'
+                ? await factoryContext(req)
+                : (factoryContext as ExtractContext<typeof factory>)
+
+            res.json(await procedure.handler(context, req.body))
             if (this.config?.onSuccess) {
               this.config.onSuccess(procedure, req, res)
             }
@@ -145,9 +184,12 @@ export class ExpressRPCAppBuilder {
    * Generates the RPC HTTP route for the given procedure.
    * @param procedure
    */
-  buildRpcHttpRouteDoc(procedure: TProcedureRegistration<any, RPCConfig>): RPCHttpRouteDoc {
+  private buildRpcHttpRouteDoc(procedure: TProcedureRegistration<any, RPCConfig>): RPCHttpRouteDoc {
     const { config } = procedure
-    const path = this.makeRPCHttpRoutePath(config)
+    const path = ExpressRPCAppBuilder.makeRPCHttpRoutePath({
+      config,
+      prefix: this.config?.pathPrefix,
+    })
     const method = 'post' // RPCs use POST method
     const jsonSchema: { body?: object; response?: object } = {}
 
@@ -164,17 +206,4 @@ export class ExpressRPCAppBuilder {
       jsonSchema,
     }
   }
-
-  /**
-   * Generates the RPC route path based on the RPC configuration.
-   * The RPCConfig name can be a string or an array of strings to form nested paths.
-   *
-   * Example
-   *  name: ['string', 'string-string', 'string']
-   *  path: /rpc/string/string-string/string/version
-   * @param config
-   */
-  makeRPCHttpRoutePath(config: RPCConfig) {
-    return `/rpc/${castArray(config.name).map(kebabCase).join('/')}/${String(config.version).trim()}`
-  }
 }

package/src/implementations/http/express-rpc/types.ts

@@ -8,7 +8,9 @@ import express from 'express'
  */
 export type ExtractContext<TFactory> = TFactory extends {
   getProcedures: () => Array<{ handler: (ctx: infer TContext, ...args: any[]) => any }>
-} ? TContext : never
+}
+  ? TContext
+  : never
 
 /**
  * Minimal structural type for a Procedures factory.
@@ -25,5 +27,7 @@ export type ProceduresFactory = {
 
 export type ExpressFactoryItem<TFactory = ReturnType<typeof Procedures<any, RPCConfig>>> = {
   factory: TFactory
-  contextResolver: (req: express.Request) => ExtractContext<TFactory>
+  factoryContext:
+    | ExtractContext<TFactory>
+    | ((req: express.Request) => ExtractContext<TFactory> | Promise<ExtractContext<TFactory>>)
 }

package/src/implementations/types.ts

@@ -7,7 +7,7 @@ export interface RPCConfig {
 
 export type FactoryItem<C> = {
   factory: ReturnType<typeof Procedures<C, RPCConfig>>
-  contextResolver: (req: Request) => C
+  factoryContext: (req: Request) => C
 }
 
 export interface RPCHttpRouteDoc {

package/build/implementations/http/client/index.d.ts

@@ -1 +0,0 @@
-export {};

package/build/implementations/http/client/index.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=index.js.map

package/build/implementations/http/client/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/implementations/http/client/index.ts"],"names":[],"mappings":""}