ts-procedures 2.1.1 → 3.0.1

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

@@ -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('/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('/echo/1')
+        .post('/echo/echo/1')
         .set('Content-Type', 'application/json')
         .send(JSON.stringify({ message: 'hello' }))
 
@@ -84,12 +84,12 @@ describe('ExpressRPCAppBuilder', () => {
       const builder = new ExpressRPCAppBuilder({ pathPrefix: '/api/v1' })
       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).post('/api/v1/test/1').send({})
+      const res = await request(app).post('/api/v1/test/test/1').send({})
       expect(res.status).toBe(200)
       expect(res.body).toEqual({ ok: true })
     })
@@ -98,12 +98,12 @@ describe('ExpressRPCAppBuilder', () => {
       const builder = new ExpressRPCAppBuilder({ pathPrefix: 'custom' })
       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).post('/custom/test/1').send({})
+      const res = await request(app).post('/custom/test/test/1').send({})
       expect(res.status).toBe(200)
     })
 
@@ -111,12 +111,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).post('/test/1').send({})
+      const res = await request(app).post('/test/test/1').send({})
       expect(res.status).toBe(200)
     })
 
@@ -124,26 +124,26 @@ describe('ExpressRPCAppBuilder', () => {
       const builder = new ExpressRPCAppBuilder({ pathPrefix: '/api' })
       const RPC = Procedures<{}, RPCConfig>()
 
-      RPC.Create('Test', { name: 'test', version: 1 }, async () => ({}))
+      RPC.Create('Test', { scope: 'test', version: 1 }, async () => ({}))
 
       builder.register(RPC, () => ({}))
       builder.build()
 
-      expect(builder.docs[0]!.path).toBe('/api/test/1')
+      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', { name: 'users', version: 1 }, async () => ({ users: [] }))
+      RPC.Create('Users', { scope: 'users', version: 1 }, async () => ({ users: [] }))
 
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      const res = await request(app).post('/rpc/users/1').send({})
+      const res = await request(app).post('/rpc/users/users/1').send({})
       expect(res.status).toBe(200)
-      expect(builder.docs[0]!.path).toBe('/rpc/users/1')
+      expect(builder.docs[0]!.path).toBe('/rpc/users/users/1')
     })
   })
 
@@ -156,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('/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', '/test/1')
+      expect(onRequestStart.mock.calls[0]![0]).toHaveProperty('path', '/test/test/1')
     })
 
     test('onRequestEnd is called after response finishes', async () => {
@@ -173,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('/test/1').send({})
+      await request(app).post('/test/test/1').send({})
 
       expect(onRequestEnd).toHaveBeenCalledTimes(1)
       expect(onRequestEnd.mock.calls[0]![0]).toHaveProperty('method', 'POST')
@@ -190,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('/test/1').send({})
+      await request(app).post('/test/test/1').send({})
 
       expect(onSuccess).toHaveBeenCalledTimes(1)
       expect(onSuccess.mock.calls[0]![0]).toHaveProperty('name', 'Test')
@@ -206,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('/test/1').send({})
+      await request(app).post('/test/test/1').send({})
 
       expect(onSuccess).not.toHaveBeenCalled()
     })
@@ -228,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 }
       })
@@ -236,7 +236,7 @@ describe('ExpressRPCAppBuilder', () => {
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      await request(app).post('/test/1').send({})
+      await request(app).post('/test/test/1').send({})
 
       expect(order).toEqual(['start', 'handler', 'success', 'end'])
     })
@@ -254,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('/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')
@@ -275,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('/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')
@@ -293,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
@@ -302,7 +302,7 @@ describe('ExpressRPCAppBuilder', () => {
       builder.register(RPC, () => ({}))
       const app = builder.build()
 
-      const res = await request(app).post('/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')
@@ -333,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,
       }))
 
@@ -347,8 +347,8 @@ describe('ExpressRPCAppBuilder', () => {
 
       const app = builder.build()
 
-      const publicRes = await request(app).post('/public/1').send({})
-      const privateRes = await request(app).post('/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 })
@@ -360,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('/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' })
     })
@@ -380,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('/get-request-id/1').send({})
+      await request(app).post('/get-request-id/get-request-id/1').send({})
 
       expect(factoryContext).toHaveBeenCalledTimes(1)
     })
@@ -400,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('/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')
@@ -426,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('/method-one/1').send({})
-      const res2 = await request(app).post('/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)
@@ -453,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)
 
@@ -462,8 +462,8 @@ describe('ExpressRPCAppBuilder', () => {
       builder.build()
 
       expect(builder.docs).toHaveLength(2)
-      expect(builder.docs[0]!.path).toBe('/method-one/1')
-      expect(builder.docs[1]!.path).toBe('/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 () => {
@@ -472,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('/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' })
     })
@@ -488,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('/test/1')
+      const res = await request(app).get('/test/test/1')
 
       expect(res.status).toBe(404)
     })
@@ -509,42 +509,42 @@ describe('ExpressRPCAppBuilder', () => {
       builder = new ExpressRPCAppBuilder()
     })
 
-    test("simple string: 'users' → /users/1", () => {
-      const path = builder.makeRPCHttpRoutePath({ name: 'users', version: 1 })
-      expect(path).toBe('/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'] → /users/get-by-id/1", () => {
-      const path = builder.makeRPCHttpRoutePath({ name: ['users', 'get-by-id'], version: 1 })
-      expect(path).toBe('/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' → /get-user-by-id/1", () => {
-      const path = builder.makeRPCHttpRoutePath({ name: 'getUserById', version: 1 })
-      expect(path).toBe('/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' → /get-user-by-id/1", () => {
-      const path = builder.makeRPCHttpRoutePath({ name: 'GetUserById', version: 1 })
-      expect(path).toBe('/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('/test/1')
-      expect(pathV2).toBe('/test/2')
-      expect(pathV99).toBe('/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('/user-module/get-active-users/1')
+      expect(path).toBe('/user-module/get-active-users/list-users/1')
     })
   })
 
@@ -565,7 +565,7 @@ describe('ExpressRPCAppBuilder', () => {
       const RPC = Procedures<{}, RPCConfig>()
       RPC.Create(
         'GetUser',
-        { name: 'users', version: 1, schema: { params: paramsSchema, returnType: returnSchema } },
+        { scope: 'users', version: 1, schema: { params: paramsSchema, returnType: returnSchema } },
         async () => ({ name: 'test' })
       )
 
@@ -573,7 +573,7 @@ describe('ExpressRPCAppBuilder', () => {
       builder.build()
 
       const doc = builder.docs[0]!
-      expect(doc.path).toBe('/users/1')
+      expect(doc.path).toBe('/users/get-user/1')
       expect(doc.method).toBe('post')
       expect(doc.jsonSchema.body).toBeDefined()
       expect(doc.jsonSchema.response).toBeDefined()
@@ -581,7 +581,7 @@ 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 }))
 
       builder.register(RPC, () => ({}))
       builder.build()
@@ -594,7 +594,7 @@ 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 () => ({})
       )
 
@@ -608,8 +608,8 @@ describe('ExpressRPCAppBuilder', () => {
 
     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 () => ({}))
 
       builder.register(RPC, () => ({}))
       builder.build()
@@ -634,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',
       }))
 
@@ -646,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() }) },
         },
@@ -656,7 +656,7 @@ describe('ExpressRPCAppBuilder', () => {
       AuthRPC.Create(
         'UpdateProfile',
         {
-          name: ['users', 'profile'],
+          scope: ['users', 'profile'],
           version: 2,
           schema: { params: v.object({ name: v.string() }) },
         },
@@ -682,24 +682,24 @@ describe('ExpressRPCAppBuilder', () => {
       const app = builder.build()
 
       // Test public endpoints
-      const versionRes = await request(app).post('/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('/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('/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('/users/profile/2')
+        .post('/users/profile/update-profile/2')
         .set('X-User-Id', 'user-456')
         .send({ name: 'John Doe' })
       expect(updateRes.status).toBe(200)
@@ -709,10 +709,10 @@ describe('ExpressRPCAppBuilder', () => {
       expect(builder.docs).toHaveLength(4)
 
       const paths = builder.docs.map((d) => d.path)
-      expect(paths).toContain('/system/version/1')
-      expect(paths).toContain('/health/1')
-      expect(paths).toContain('/users/profile/1')
-      expect(paths).toContain('/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')

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

@@ -86,20 +86,27 @@ export class ExpressRPCAppBuilder {
    *  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()}`
+  static makeRPCHttpRoutePath({
+    name,
+    config,
+    prefix,
+  }: {
+    name: string
+    prefix?: string
+    config: RPCConfig
+  }) {
+    const normalizedPrefix = prefix ? (prefix.startsWith('/') ? prefix : `/${prefix}`) : ''
+
+    return `${normalizedPrefix}/${castArray(config.scope).map(kebabCase).join('/')}/${kebabCase(name)}/${String(config.version).trim()}`
   }
 
   /**
    * Instance method wrapper for makeRPCHttpRoutePath that uses the builder's pathPrefix.
    * @param config - The RPC configuration
    */
-  makeRPCHttpRoutePath(config: RPCConfig): string {
+  makeRPCHttpRoutePath(name: string, config: RPCConfig): string {
     return ExpressRPCAppBuilder.makeRPCHttpRoutePath({
+      name,
       config,
       prefix: this.config?.pathPrefix,
     })
@@ -187,6 +194,7 @@ export class ExpressRPCAppBuilder {
   private buildRpcHttpRouteDoc(procedure: TProcedureRegistration<any, RPCConfig>): RPCHttpRouteDoc {
     const { config } = procedure
     const path = ExpressRPCAppBuilder.makeRPCHttpRoutePath({
+      name: procedure.name,
       config,
       prefix: this.config?.pathPrefix,
     })