ts-procedures 2.1.1 → 3.0.1

package/build/implementations/http/express-rpc/index.test.js

@@ -18,11 +18,11 @@ describe('ExpressRPCAppBuilder', () => {
         test('creates default Express app with json middleware', async () => {
             const builder = new ExpressRPCAppBuilder();
             const RPC = Procedures();
-            RPC.Create('Echo', { name: 'echo', version: 1, schema: { params: v.object({ message: v.string() }) } }, async (ctx, params) => params);
+            RPC.Create('Echo', { scope: 'echo', version: 1, schema: { params: v.object({ message: v.string() }) } }, async (ctx, params) => params);
             builder.register(RPC, () => ({ userId: '123' }));
             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' });
         });
@@ -31,12 +31,12 @@ describe('ExpressRPCAppBuilder', () => {
             // Intentionally NOT adding json middleware
             const builder = new ExpressRPCAppBuilder({ app: customApp });
             const RPC = Procedures();
-            RPC.Create('Echo', { name: 'echo', version: 1, schema: { params: v.object({ message: v.string() }) } }, async (ctx, params) => ({ received: params }));
+            RPC.Create('Echo', { scope: 'echo', version: 1, schema: { params: v.object({ message: v.string() }) } }, async (ctx, params) => ({ received: params }));
             builder.register(RPC, () => ({ userId: '123' }));
             const app = builder.build();
             // 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' }));
             // Request body is undefined since json middleware wasn't added
@@ -61,48 +61,48 @@ describe('ExpressRPCAppBuilder', () => {
         test('uses custom pathPrefix for all routes', async () => {
             const builder = new ExpressRPCAppBuilder({ pathPrefix: '/api/v1' });
             const RPC = Procedures();
-            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 });
         });
         test('pathPrefix without leading slash gets normalized', async () => {
             const builder = new ExpressRPCAppBuilder({ pathPrefix: 'custom' });
             const RPC = Procedures();
-            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);
         });
         test('no prefix when pathPrefix not specified', async () => {
             const builder = new ExpressRPCAppBuilder();
             const RPC = Procedures();
-            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);
         });
         test('pathPrefix appears in generated docs', () => {
             const builder = new ExpressRPCAppBuilder({ pathPrefix: '/api' });
             const RPC = Procedures();
-            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();
-            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');
         });
     });
     // --------------------------------------------------------------------------
@@ -113,22 +113,22 @@ describe('ExpressRPCAppBuilder', () => {
             const onRequestStart = vi.fn();
             const builder = new ExpressRPCAppBuilder({ onRequestStart });
             const RPC = Procedures();
-            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 () => {
             const onRequestEnd = vi.fn();
             const builder = new ExpressRPCAppBuilder({ onRequestEnd });
             const RPC = Procedures();
-            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');
             expect(onRequestEnd.mock.calls[0][1]).toHaveProperty('statusCode', 200);
@@ -137,10 +137,10 @@ describe('ExpressRPCAppBuilder', () => {
             const onSuccess = vi.fn();
             const builder = new ExpressRPCAppBuilder({ onSuccess });
             const RPC = Procedures();
-            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');
         });
@@ -148,12 +148,12 @@ describe('ExpressRPCAppBuilder', () => {
             const onSuccess = vi.fn();
             const builder = new ExpressRPCAppBuilder({ onSuccess });
             const RPC = Procedures();
-            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();
         });
         test('hooks execute in correct order: start → handler → success → end', async () => {
@@ -164,13 +164,13 @@ describe('ExpressRPCAppBuilder', () => {
                 onSuccess: () => order.push('success'),
             });
             const RPC = Procedures();
-            RPC.Create('Test', { name: 'test', version: 1 }, async () => {
+            RPC.Create('Test', { scope: 'test', version: 1 }, async () => {
                 order.push('handler');
                 return { 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(order).toEqual(['start', 'handler', 'success', 'end']);
         });
     });
@@ -184,12 +184,12 @@ describe('ExpressRPCAppBuilder', () => {
             });
             const builder = new ExpressRPCAppBuilder({ error: errorHandler });
             const RPC = Procedures();
-            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');
             expect(errorHandler.mock.calls[0][3]).toBeInstanceOf(Error);
@@ -200,12 +200,12 @@ describe('ExpressRPCAppBuilder', () => {
         test('default error handling returns error message in response', async () => {
             const builder = new ExpressRPCAppBuilder();
             const RPC = Procedures();
-            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');
             expect(res.body.error).toContain('Something went wrong');
@@ -213,14 +213,14 @@ describe('ExpressRPCAppBuilder', () => {
         test('catches unhandled exceptions in handler', async () => {
             const builder = new ExpressRPCAppBuilder();
             const RPC = Procedures();
-            RPC.Create('Test', { name: 'test', version: 1 }, async () => {
+            RPC.Create('Test', { scope: 'test', version: 1 }, async () => {
                 // Simulate unhandled exception
                 const obj = null;
                 return obj.property; // This will throw
             });
             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');
         });
@@ -243,18 +243,18 @@ describe('ExpressRPCAppBuilder', () => {
             const builder = new ExpressRPCAppBuilder();
             const PublicRPC = Procedures();
             const PrivateRPC = Procedures();
-            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,
             }));
             builder
                 .register(PublicRPC, () => ({ public: true }))
                 .register(PrivateRPC, () => ({ private: true }));
             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 });
         });
@@ -262,12 +262,12 @@ describe('ExpressRPCAppBuilder', () => {
             const factoryContext = { requestId: 'req-123' };
             const builder = new ExpressRPCAppBuilder();
             const RPC = Procedures();
-            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' });
         });
         test('factoryContext can be async function', async () => {
@@ -276,12 +276,12 @@ describe('ExpressRPCAppBuilder', () => {
             });
             const builder = new ExpressRPCAppBuilder();
             const RPC = Procedures();
-            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);
         });
         test('factoryContext function receives Express request object', async () => {
@@ -290,12 +290,12 @@ describe('ExpressRPCAppBuilder', () => {
             }));
             const builder = new ExpressRPCAppBuilder();
             const RPC = Procedures();
-            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');
             expect(factoryContext.mock.calls[0][0].headers).toHaveProperty('authorization', 'Bearer token123');
@@ -308,12 +308,12 @@ describe('ExpressRPCAppBuilder', () => {
         test('creates POST routes for all procedures', async () => {
             const builder = new ExpressRPCAppBuilder();
             const RPC = Procedures();
-            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);
             expect(res1.body).toEqual({ m: 1 });
@@ -328,31 +328,31 @@ describe('ExpressRPCAppBuilder', () => {
         test('populates docs array after build', () => {
             const builder = new ExpressRPCAppBuilder();
             const RPC = Procedures();
-            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);
             builder.register(RPC, () => ({}));
             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 () => {
             const builder = new ExpressRPCAppBuilder();
             const RPC = Procedures();
-            RPC.Create('Echo', { name: 'echo', version: 1, schema: { params: v.object({ data: v.string() }) } }, async (ctx, params) => ({ received: params.data }));
+            RPC.Create('Echo', { 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' });
         });
         test('GET requests return 404 (RPC uses POST only)', async () => {
             const builder = new ExpressRPCAppBuilder();
             const RPC = Procedures();
-            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);
         });
     });
@@ -364,36 +364,36 @@ describe('ExpressRPCAppBuilder', () => {
         beforeEach(() => {
             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 });
-            expect(pathV1).toBe('/test/1');
-            expect(pathV2).toBe('/test/2');
-            expect(pathV99).toBe('/test/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/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');
         });
     });
     // --------------------------------------------------------------------------
@@ -408,18 +408,18 @@ describe('ExpressRPCAppBuilder', () => {
             const paramsSchema = v.object({ id: v.string() });
             const returnSchema = v.object({ name: v.string() });
             const RPC = Procedures();
-            RPC.Create('GetUser', { name: 'users', version: 1, schema: { params: paramsSchema, returnType: returnSchema } }, async () => ({ name: 'test' }));
+            RPC.Create('GetUser', { scope: 'users', version: 1, schema: { params: paramsSchema, returnType: returnSchema } }, async () => ({ name: 'test' }));
             builder.register(RPC, () => ({}));
             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();
         });
         test('omits body schema when no params defined', () => {
             const RPC = Procedures();
-            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();
             const doc = builder.docs[0];
@@ -427,7 +427,7 @@ describe('ExpressRPCAppBuilder', () => {
         });
         test('omits response schema when no returnType defined', () => {
             const RPC = Procedures();
-            RPC.Create('NoReturn', { name: 'no-return', version: 1, schema: { params: v.object({ x: v.number() }) } }, async () => ({}));
+            RPC.Create('NoReturn', { scope: 'no-return', version: 1, schema: { params: v.object({ x: v.number() }) } }, async () => ({}));
             builder.register(RPC, () => ({}));
             builder.build();
             const doc = builder.docs[0];
@@ -436,8 +436,8 @@ describe('ExpressRPCAppBuilder', () => {
         });
         test("method is always 'post'", () => {
             const RPC = Procedures();
-            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();
             builder.docs.forEach((doc) => {
@@ -454,20 +454,20 @@ describe('ExpressRPCAppBuilder', () => {
             const PublicRPC = Procedures();
             const AuthRPC = Procedures();
             // 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',
             }));
             // Create authenticated procedures
             AuthRPC.Create('GetProfile', {
-                name: ['users', 'profile'],
+                scope: ['users', 'profile'],
                 version: 1,
                 schema: { returnType: v.object({ userId: v.string(), source: v.string() }) },
             }, async (ctx) => ({ userId: ctx.userId, source: ctx.source }));
             AuthRPC.Create('UpdateProfile', {
-                name: ['users', 'profile'],
+                scope: ['users', 'profile'],
                 version: 2,
                 schema: { params: v.object({ name: v.string() }) },
             }, async (ctx, params) => ({ userId: ctx.userId, name: params.name }));
@@ -486,21 +486,21 @@ 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);
@@ -508,10 +508,10 @@ describe('ExpressRPCAppBuilder', () => {
             // Verify documentation
             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');
             expect(events).toContain('success:GetVersion');