ts-procedures 2.1.0 → 3.0.0

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', () => {
   // --------------------------------------------------------------------------
@@ -23,7 +23,7 @@ describe('ExpressRPCAppBuilder', () => {
 
       RPC.Create(
         'Echo',
-        { name: 'echo', version: 1, schema: { params: v.object({ message: v.string() }) } },
+        { scope: 'echo', version: 1, schema: { params: v.object({ message: v.string() }) } },
         async (ctx, params) => params
       )
 
@@ -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/echo/1').send({ message: 'hello' })
 
       expect(res.status).toBe(200)
       expect(res.body).toEqual({ message: 'hello' })
@@ -45,7 +45,7 @@ describe('ExpressRPCAppBuilder', () => {
 
       RPC.Create(
         'Echo',
-        { name: 'echo', version: 1, schema: { params: v.object({ message: v.string() }) } },
+        { scope: 'echo', version: 1, schema: { params: v.object({ message: v.string() }) } },
         async (ctx, params) => ({ received: params })
       )
 
@@ -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/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', { scope: 'test', version: 1 }, async () => ({ ok: true }))
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      const res = await request(app).post('/api/v1/test/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', { scope: 'test', version: 1 }, async () => ({ ok: true }))
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      const res = await request(app).post('/custom/test/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', { scope: 'test', version: 1 }, async () => ({ ok: true }))
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      const res = await request(app).post('/test/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', { scope: 'test', version: 1 }, async () => ({}))
+
+      builder.register(RPC, () => ({}))
+      builder.build()
+
+      expect(builder.docs[0]!.path).toBe('/api/test/test/1')
+    })
+
+    test('pathPrefix /rpc restores original behavior', async () => {
+      const builder = new ExpressRPCAppBuilder({ pathPrefix: '/rpc' })
+      const RPC = Procedures<{}, RPCConfig>()
+
+      RPC.Create('Users', { scope: 'users', version: 1 }, async () => ({ users: [] }))
+
+      builder.register(RPC, () => ({}))
+      const app = builder.build()
+
+      const res = await request(app).post('/rpc/users/users/1').send({})
+      expect(res.status).toBe(200)
+      expect(builder.docs[0]!.path).toBe('/rpc/users/users/1')
+    })
+  })
+
   // --------------------------------------------------------------------------
   // Lifecycle Hooks Tests
   // --------------------------------------------------------------------------
@@ -85,16 +156,16 @@ describe('ExpressRPCAppBuilder', () => {
       const builder = new ExpressRPCAppBuilder({ onRequestStart })
       const RPC = Procedures<{}, RPCConfig>()
 
-      RPC.Create('Test', { name: 'test', version: 1 }, async () => ({ ok: true }))
+      RPC.Create('Test', { scope: 'test', version: 1 }, async () => ({ ok: true }))
 
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      await request(app).post('/rpc/test/1').send({})
+      await request(app).post('/test/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/test/1')
     })
 
     test('onRequestEnd is called after response finishes', async () => {
@@ -102,12 +173,12 @@ describe('ExpressRPCAppBuilder', () => {
       const builder = new ExpressRPCAppBuilder({ onRequestEnd })
       const RPC = Procedures<{}, RPCConfig>()
 
-      RPC.Create('Test', { name: 'test', version: 1 }, async () => ({ ok: true }))
+      RPC.Create('Test', { scope: 'test', version: 1 }, async () => ({ ok: true }))
 
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      await request(app).post('/rpc/test/1').send({})
+      await request(app).post('/test/test/1').send({})
 
       expect(onRequestEnd).toHaveBeenCalledTimes(1)
       expect(onRequestEnd.mock.calls[0]![0]).toHaveProperty('method', 'POST')
@@ -119,12 +190,12 @@ describe('ExpressRPCAppBuilder', () => {
       const builder = new ExpressRPCAppBuilder({ onSuccess })
       const RPC = Procedures<{}, RPCConfig>()
 
-      RPC.Create('Test', { name: 'test', version: 1 }, async () => ({ ok: true }))
+      RPC.Create('Test', { scope: 'test', version: 1 }, async () => ({ ok: true }))
 
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      await request(app).post('/rpc/test/1').send({})
+      await request(app).post('/test/test/1').send({})
 
       expect(onSuccess).toHaveBeenCalledTimes(1)
       expect(onSuccess.mock.calls[0]![0]).toHaveProperty('name', 'Test')
@@ -135,14 +206,14 @@ describe('ExpressRPCAppBuilder', () => {
       const builder = new ExpressRPCAppBuilder({ onSuccess })
       const RPC = Procedures<{}, RPCConfig>()
 
-      RPC.Create('Test', { name: 'test', version: 1 }, async () => {
+      RPC.Create('Test', { scope: 'test', version: 1 }, async () => {
         throw new Error('Handler error')
       })
 
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      await request(app).post('/rpc/test/1').send({})
+      await request(app).post('/test/test/1').send({})
 
       expect(onSuccess).not.toHaveBeenCalled()
     })
@@ -157,7 +228,7 @@ describe('ExpressRPCAppBuilder', () => {
       })
       const RPC = Procedures<{}, RPCConfig>()
 
-      RPC.Create('Test', { name: 'test', version: 1 }, async () => {
+      RPC.Create('Test', { scope: 'test', version: 1 }, async () => {
         order.push('handler')
         return { ok: true }
       })
@@ -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/test/1').send({})
 
       expect(order).toEqual(['start', 'handler', 'success', 'end'])
     })
@@ -183,14 +254,14 @@ describe('ExpressRPCAppBuilder', () => {
       const builder = new ExpressRPCAppBuilder({ error: errorHandler })
       const RPC = Procedures<{}, RPCConfig>()
 
-      RPC.Create('Test', { name: 'test', version: 1 }, async () => {
+      RPC.Create('Test', { scope: 'test', version: 1 }, async () => {
         throw new Error('Test error')
       })
 
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      const res = await request(app).post('/rpc/test/1').send({})
+      const res = await request(app).post('/test/test/1').send({})
 
       expect(errorHandler).toHaveBeenCalledTimes(1)
       expect(errorHandler.mock.calls[0]![0]).toHaveProperty('name', 'Test')
@@ -204,14 +275,14 @@ describe('ExpressRPCAppBuilder', () => {
       const builder = new ExpressRPCAppBuilder()
       const RPC = Procedures<{}, RPCConfig>()
 
-      RPC.Create('Test', { name: 'test', version: 1 }, async () => {
+      RPC.Create('Test', { scope: 'test', version: 1 }, async () => {
         throw new Error('Something went wrong')
       })
 
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      const res = await request(app).post('/rpc/test/1').send({})
+      const res = await request(app).post('/test/test/1').send({})
 
       // Default error handler returns error message in JSON body
       expect(res.body).toHaveProperty('error')
@@ -222,7 +293,7 @@ describe('ExpressRPCAppBuilder', () => {
       const builder = new ExpressRPCAppBuilder()
       const RPC = Procedures<{}, RPCConfig>()
 
-      RPC.Create('Test', { name: 'test', version: 1 }, async () => {
+      RPC.Create('Test', { scope: 'test', version: 1 }, async () => {
         // Simulate unhandled exception
         const obj: any = null
         return obj.property // This will throw
@@ -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/test/1').send({})
 
       // Unhandled exceptions are caught and returned as error response
       expect(res.body).toHaveProperty('error')
@@ -262,11 +333,11 @@ describe('ExpressRPCAppBuilder', () => {
       const PublicRPC = Procedures<{ public: true }, RPCConfig>()
       const PrivateRPC = Procedures<{ private: true }, RPCConfig>()
 
-      PublicRPC.Create('PublicMethod', { name: 'public', version: 1 }, async (ctx) => ({
+      PublicRPC.Create('PublicMethod', { scope: 'public', version: 1 }, async (ctx) => ({
         isPublic: ctx.public,
       }))
 
-      PrivateRPC.Create('PrivateMethod', { name: 'private', version: 1 }, async (ctx) => ({
+      PrivateRPC.Create('PrivateMethod', { scope: 'private', version: 1 }, async (ctx) => ({
         isPrivate: ctx.private,
       }))
 
@@ -276,8 +347,8 @@ 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/public-method/1').send({})
+      const privateRes = await request(app).post('/private/private-method/1').send({})
 
       expect(publicRes.body).toEqual({ isPublic: true })
       expect(privateRes.body).toEqual({ isPrivate: true })
@@ -289,14 +360,14 @@ describe('ExpressRPCAppBuilder', () => {
       const builder = new ExpressRPCAppBuilder()
       const RPC = Procedures<{ requestId: string }, RPCConfig>()
 
-      RPC.Create('GetRequestId', { name: 'get-request-id', version: 1 }, async (ctx) => ({
+      RPC.Create('GetRequestId', { scope: 'get-request-id', version: 1 }, async (ctx) => ({
         id: ctx.requestId,
       }))
 
       builder.register(RPC, factoryContext)
       const app = builder.build()
 
-      const res = await request(app).post('/rpc/get-request-id/1').send({})
+      const res = await request(app).post('/get-request-id/get-request-id/1').send({})
 
       expect(res.body).toEqual({ id: 'req-123' })
     })
@@ -309,14 +380,14 @@ describe('ExpressRPCAppBuilder', () => {
       const builder = new ExpressRPCAppBuilder()
       const RPC = Procedures<{ requestId: string }, RPCConfig>()
 
-      RPC.Create('GetRequestId', { name: 'get-request-id', version: 1 }, async (ctx) => ({
+      RPC.Create('GetRequestId', { scope: 'get-request-id', version: 1 }, async (ctx) => ({
         id: ctx.requestId,
       }))
 
       builder.register(RPC, factoryContext)
       const app = builder.build()
 
-      await request(app).post('/rpc/get-request-id/1').send({})
+      await request(app).post('/get-request-id/get-request-id/1').send({})
 
       expect(factoryContext).toHaveBeenCalledTimes(1)
     })
@@ -329,14 +400,14 @@ describe('ExpressRPCAppBuilder', () => {
       const builder = new ExpressRPCAppBuilder()
       const RPC = Procedures<{ authHeader?: string }, RPCConfig>()
 
-      RPC.Create('GetAuth', { name: 'get-auth', version: 1 }, async (ctx) => ({
+      RPC.Create('GetAuth', { scope: 'get-auth', version: 1 }, async (ctx) => ({
         auth: ctx.authHeader,
       }))
 
       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/get-auth/1').set('Authorization', 'Bearer token123').send({})
 
       expect(factoryContext).toHaveBeenCalledTimes(1)
       expect(factoryContext.mock.calls[0]![0]).toHaveProperty('headers')
@@ -355,14 +426,14 @@ describe('ExpressRPCAppBuilder', () => {
       const builder = new ExpressRPCAppBuilder()
       const RPC = Procedures<{}, RPCConfig>()
 
-      RPC.Create('MethodOne', { name: 'method-one', version: 1 }, async () => ({ m: 1 }))
-      RPC.Create('MethodTwo', { name: 'method-two', version: 2 }, async () => ({ m: 2 }))
+      RPC.Create('MethodOne', { scope: 'method-one', version: 1 }, async () => ({ m: 1 }))
+      RPC.Create('MethodTwo', { scope: 'method-two', version: 2 }, async () => ({ m: 2 }))
 
       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/method-one/1').send({})
+      const res2 = await request(app).post('/method-two/method-two/2').send({})
 
       expect(res1.status).toBe(200)
       expect(res2.status).toBe(200)
@@ -382,8 +453,8 @@ describe('ExpressRPCAppBuilder', () => {
       const builder = new ExpressRPCAppBuilder()
       const RPC = Procedures<{}, RPCConfig>()
 
-      RPC.Create('MethodOne', { name: 'method-one', version: 1 }, async () => ({}))
-      RPC.Create('MethodTwo', { name: ['nested', 'method'], version: 2 }, async () => ({}))
+      RPC.Create('MethodOne', { scope: 'method-one', version: 1 }, async () => ({}))
+      RPC.Create('MethodTwo', { scope: ['nested', 'method'], version: 2 }, async () => ({}))
 
       expect(builder.docs).toHaveLength(0)
 
@@ -391,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/method-one/1')
+      expect(builder.docs[1]!.path).toBe('/nested/method/method-two/2')
     })
 
     test('passes request body to handler as params', async () => {
@@ -401,14 +472,14 @@ describe('ExpressRPCAppBuilder', () => {
 
       RPC.Create(
         'Echo',
-        { name: 'echo', version: 1, schema: { params: v.object({ data: v.string() }) } },
+        { scope: 'echo', version: 1, schema: { params: v.object({ data: v.string() }) } },
         async (ctx, params) => ({ received: params.data })
       )
 
       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/echo/1').send({ data: 'test-data' })
 
       expect(res.body).toEqual({ received: 'test-data' })
     })
@@ -417,12 +488,12 @@ describe('ExpressRPCAppBuilder', () => {
       const builder = new ExpressRPCAppBuilder()
       const RPC = Procedures<{}, RPCConfig>()
 
-      RPC.Create('Test', { name: 'test', version: 1 }, async () => ({ ok: true }))
+      RPC.Create('Test', { scope: 'test', version: 1 }, async () => ({ ok: true }))
 
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      const res = await request(app).get('/rpc/test/1')
+      const res = await request(app).get('/test/test/1')
 
       expect(res.status).toBe(404)
     })
@@ -438,42 +509,42 @@ describe('ExpressRPCAppBuilder', () => {
       builder = new ExpressRPCAppBuilder()
     })
 
-    test("simple string: 'users' → /rpc/users/1", () => {
-      const path = builder.makeRPCHttpRoutePath({ name: 'users', version: 1 })
-      expect(path).toBe('/rpc/users/1')
+    test("simple scope with procedure name: 'users' + 'GetUser' → /users/get-user/1", () => {
+      const path = builder.makeRPCHttpRoutePath('GetUser', { scope: 'users', version: 1 })
+      expect(path).toBe('/users/get-user/1')
     })
 
-    test("array name: ['users', 'get-by-id'] → /rpc/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')
+    test("array scope with procedure name: ['users', 'profile'] + 'GetById' → /users/profile/get-by-id/1", () => {
+      const path = builder.makeRPCHttpRoutePath('GetById', { scope: ['users', 'profile'], version: 1 })
+      expect(path).toBe('/users/profile/get-by-id/1')
     })
 
-    test("camelCase: 'getUserById' → /rpc/get-user-by-id/1", () => {
-      const path = builder.makeRPCHttpRoutePath({ name: 'getUserById', version: 1 })
-      expect(path).toBe('/rpc/get-user-by-id/1')
+    test("camelCase procedure name: 'users' + 'getProfile' → /users/get-profile/1", () => {
+      const path = builder.makeRPCHttpRoutePath('getProfile', { scope: 'users', version: 1 })
+      expect(path).toBe('/users/get-profile/1')
     })
 
-    test("PascalCase: 'GetUserById' → /rpc/get-user-by-id/1", () => {
-      const path = builder.makeRPCHttpRoutePath({ name: 'GetUserById', version: 1 })
-      expect(path).toBe('/rpc/get-user-by-id/1')
+    test("PascalCase procedure name: 'users' + 'UpdateProfile' → /users/update-profile/1", () => {
+      const path = builder.makeRPCHttpRoutePath('UpdateProfile', { scope: 'users', version: 1 })
+      expect(path).toBe('/users/update-profile/1')
     })
 
     test('version number included in path', () => {
-      const pathV1 = builder.makeRPCHttpRoutePath({ name: 'test', version: 1 })
-      const pathV2 = builder.makeRPCHttpRoutePath({ name: 'test', version: 2 })
-      const pathV99 = builder.makeRPCHttpRoutePath({ name: 'test', version: 99 })
+      const pathV1 = builder.makeRPCHttpRoutePath('Test', { scope: 'test', version: 1 })
+      const pathV2 = builder.makeRPCHttpRoutePath('Test', { scope: 'test', version: 2 })
+      const pathV99 = builder.makeRPCHttpRoutePath('Test', { scope: '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/test/1')
+      expect(pathV2).toBe('/test/test/2')
+      expect(pathV99).toBe('/test/test/99')
     })
 
     test('handles mixed case in array segments', () => {
-      const path = builder.makeRPCHttpRoutePath({
-        name: ['UserModule', 'getActiveUsers'],
+      const path = builder.makeRPCHttpRoutePath('ListUsers', {
+        scope: ['UserModule', 'getActiveUsers'],
         version: 1,
       })
-      expect(path).toBe('/rpc/user-module/get-active-users/1')
+      expect(path).toBe('/user-module/get-active-users/list-users/1')
     })
   })
 
@@ -492,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 } },
+        { scope: '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/get-user/1')
       expect(doc.method).toBe('post')
       expect(doc.jsonSchema.body).toBeDefined()
       expect(doc.jsonSchema.response).toBeDefined()
@@ -509,11 +581,12 @@ describe('ExpressRPCAppBuilder', () => {
 
     test('omits body schema when no params defined', () => {
       const RPC = Procedures<{}, RPCConfig>()
-      RPC.Create('NoParams', { name: 'no-params', version: 1 }, async () => ({ ok: true }))
+      RPC.Create('NoParams', { scope: '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()
     })
 
@@ -521,26 +594,27 @@ describe('ExpressRPCAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
       RPC.Create(
         'NoReturn',
-        { name: 'no-return', version: 1, schema: { params: v.object({ x: v.number() }) } },
+        { scope: 'no-return', version: 1, schema: { params: v.object({ x: v.number() }) } },
         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()
     })
 
     test("method is always 'post'", () => {
       const RPC = Procedures<{}, RPCConfig>()
-      RPC.Create('Test1', { name: 't1', version: 1 }, async () => ({}))
-      RPC.Create('Test2', { name: 't2', version: 2 }, async () => ({}))
+      RPC.Create('Test1', { scope: 't1', version: 1 }, async () => ({}))
+      RPC.Create('Test2', { scope: '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')
       })
     })
@@ -560,11 +634,11 @@ describe('ExpressRPCAppBuilder', () => {
       const AuthRPC = Procedures<AuthContext, RPCConfig>()
 
       // Create public procedures
-      PublicRPC.Create('GetVersion', { name: ['system', 'version'], version: 1 }, async () => ({
+      PublicRPC.Create('GetVersion', { scope: ['system', 'version'], version: 1 }, async () => ({
         version: '1.0.0',
       }))
 
-      PublicRPC.Create('HealthCheck', { name: 'health', version: 1 }, async () => ({
+      PublicRPC.Create('HealthCheck', { scope: 'health', version: 1 }, async () => ({
         status: 'ok',
       }))
 
@@ -572,7 +646,7 @@ describe('ExpressRPCAppBuilder', () => {
       AuthRPC.Create(
         'GetProfile',
         {
-          name: ['users', 'profile'],
+          scope: ['users', 'profile'],
           version: 1,
           schema: { returnType: v.object({ userId: v.string(), source: v.string() }) },
         },
@@ -582,7 +656,7 @@ describe('ExpressRPCAppBuilder', () => {
       AuthRPC.Create(
         'UpdateProfile',
         {
-          name: ['users', 'profile'],
+          scope: ['users', 'profile'],
           version: 2,
           schema: { params: v.object({ name: v.string() }) },
         },
@@ -608,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/get-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/health-check/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/get-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/update-profile/2')
         .set('X-User-Id', 'user-456')
         .send({ name: 'John Doe' })
       expect(updateRes.status).toBe(200)
@@ -635,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/get-version/1')
+      expect(paths).toContain('/health/health-check/1')
+      expect(paths).toContain('/users/profile/get-profile/1')
+      expect(paths).toContain('/users/profile/update-profile/2')
 
       // Verify hooks were called
       expect(events).toContain('request-start')